X_eTaL documentation

Files

Items

namekindtype
lowersvalueChar
ʰw̲ordsfunctionChar -> Box Char
ʰn̲amefunctionChar -> Char
ʰw̲idthfunctionChar -> Int
ʰc̲omponent?functionTruthy a => Char -> a
ʰg̲etterfunctionChar -> Char
ʰt̲rimfunctionChar -> Char
ʰt̲itlefunctionChar -> Char
ᵐc̲omponents<macroChar -> Char -> Char
ʰd̲efsfunction(Char, Int, Int, Int, Char) -> Char
ˡl̲inesfunction(Any a, Num b) => Box a -> b
ˡh̲oldsfunctionTruthy a => Int -> Int -> a
ˡj̲oinfunctionBox Char -> Char
ˡc̲ellfunctionNum a => a -> a -> a
ˡr̲cfunctionInt -> Int -> Int
ˡa̲roundfunctionNum a => a -> a
ˡp̲lusfunctionNum a => a -> a
ˡs̲pacedfunctionChar -> Char
ˡa̲livefunction(Num a, Truthy b) => a -> b
ˡc̲ountfunction(Num a, Num b, Truthy b) => a -> b
ˡp̲utfunctionFloat -> (Int, Int, Float) -> Float
ˡs̲pawnfunctionFloat -> Int -> (Float, Int)
ˡd̲espawnfunctionFloat -> Int -> Float
ˡn̲earfunction(Num a, Truthy b) => (a, a, a) -> b
ˡl̲inefunctionAny a => a -> Char
ˡn̲umbersInfunctionChar -> Int
ˡn̲umbersfunctionAny a => a -> Int
ˡn̲umberfunctionAny a => a -> Int
ˡl̲etterfunctionAny a => a -> Char -> Int
ˡu̲pdatefunctionInt -> Int -> Int
ˡp̲utfunctionInt -> Int -> Int
ˡn̲umfunctionBox Char -> Float
ˡw̲holefunctionFloat -> Char
ˡu̲nitfunctionNum a => a -> Float
ˡr̲ectfunctionFloat -> a -> Box Char
ˡw̲ordsfunction(Float, Float, Float) -> a -> Box Char
ˡh̲itfunctionNum a => a -> a -> Int
ˡb̲uttonsfunctionFloat -> Int -> Float
ˡm̲enufunctionFloat -> Float -> Float
ʰf̲illfunctionInt -> Char
ˡl̲abeledfunction(Float, Int) -> Box a -> Box Char
ˡc̲hoicesfunctionFloat -> Box a -> Box Char
ˡp̲icturefunctionFloat -> Box Char -> Char
ˢu̲se<built-in macroChar -> Char -> Unit
ˢi̲f<macroChar -> Char -> Char
ˢu̲nless<macroChar -> Char -> Char
ˢe̲ach<macroChar -> Char -> Char
ˢl̲ine<macroUnit -> Unit -> Char
ˢf̲ile<macroUnit -> Unit -> Char
ˢi̲nclude<macroUnit -> Char -> Char
ˢc̲fg<macroUnit -> Char -> Char
ˢe̲rror<macroChar -> Char -> Char
ˢd̲bg<macroUnit -> Char -> Char
ˢa̲ssert<macroChar -> a -> Char
ˢf̲ormat<macroUnit -> Char -> Char
ˢp̲anic<macroUnit -> Char -> Char
ˢt̲odo<macroUnit -> Char -> Char
ˢt̲ry<macroChar -> Char -> Char
ˢc̲atch<macroChar -> Char -> Char
ˢf̲inally<macroChar -> Char -> Char
ˢr̲ecover<macroUnit -> Char -> Char
ˢr̲etry<macroUnit -> Unit -> Char
ˢh̲alt<macroUnit -> Unit -> Char
ˢc̲ontinue<macroUnit -> Unit -> Char
catchCodesvalueChar
ʰm̲atchCodefunctionChar -> Char
ifArgsvalueChar
eachAlonevalueChar
eachHolevalueChar
ʰt̲rimfunctionChar -> Char
ʰw̲ordsfunctionChar -> Box Char
ʰs̲epsfunctionTruthy a => Char -> a
ʰh̲olesfunction(Num a, Truthy a) => Char -> a
ʰj̲oinfunctionBox Char -> Char
ʰq̲uotefunctionChar -> Char
ʰc̲opyfunctionChar -> Char -> Char
ʰw̲hyfunctionChar -> Char
ʰo̲rEmptyfunctionChar -> Char
ʰl̲itfunctionChar -> Char
ʰc̲jfunctionChar -> Char -> Char
ʰp̲iecesfunctionChar -> Char
pvalueInt
rvalueInt
movedvalueInt
ᵘr̲acefunctionInt -> Int
finalvalueInt
_functionUnit
_functionUnit
ˡfinishvalueInt
ˡn̲amesfunctionUnit -> Char
ˡn̲ewfunctionNum a => Int -> a
ˡr̲ollfunctiona -> Int
ˡm̲ovefunctionNum a => a -> a -> a
ˡs̲tatusfunctionTruthy a => Int -> a
ˡl̲eadersfunction(Num a, Truthy b) => a -> b
ˡw̲innersfunctionNum a => a -> Int
ˡv̲iewfunctionInt -> Char
ᵘr̲acefunctionInt -> Int
ᵘa̲skfunctiona -> Int
ᵘb̲etfunctionInt -> Char
tvalueInt
ᵘp̲layfunctionNum a => Int -> Int -> a
startvalueInt
svalueInt
ᵘr̲oundfunctionInt -> Int
st0valueInt
stvalueInt
nvalueInt
_functionUnit
_functionUnit
ˡtopvalueInt
ˡn̲ewfunctionInt -> Int
ˡm̲ovefunction(Ord a, Num b, Truthy b) => a -> a -> b
ˡs̲tatusfunction(Eq a, Truthy b) => a -> a -> b
ˡr̲eplyfunctionInt -> Char
ˡg̲uessfunctionInt -> Int
ˡn̲arrowfunctionNum a => Int -> a -> Int
ˡp̲ossiblefunctionTruthy a => Int -> Int -> a
_functionChar
_functionChar
tvalueInt
ᵘa̲skfunctionAny a => a -> Int
ᵘt̲urnfunctionNum a => a -> a
nvalueInt
_functionChar
_functionChar
_functionChar
ᵘa̲skfunctionAny a => a -> Int
ᵘs̲howfunctionInt -> Char
ᵘt̲urnfunctionInt -> Char
ᵘs̲ayfunctionInt -> Int
ᵘa̲fterfunctionInt -> Char
ᵘs̲canfunctionInt -> Int
ᵘe̲ndfunctionInt -> Char
ˡnvalueInt
ˡheadvalueInt
ˡp̲osfunctiona -> a
ˡt̲elefunctiona -> a
ˡt̲urnfunctiona -> a
ˡe̲ventfunctiona -> a
ˡs̲tatusfunctiona -> a
ˡr̲obotsfunctiona -> a
ˡa̲livefunctiona -> a
ˡw̲recksfunctiona -> a
ˡc̲ellfunctionNum a => a -> a
ˡo̲nSquaresfunction(Num a, Truthy a) => Int -> a -> a
ˡn̲ewfunctionAny a => a -> Int
ˡc̲hasefunctionInt -> Int
ˡk̲eysfunctionNum a => Unit -> a
ˡo̲nfunctionInt -> Int -> Int
ˡm̲ovedfunctionNum a => a -> a -> a
ˡm̲ovefunctionInt -> Int -> Int
ˡt̲eleportfunctionInt -> Int
ˡm̲essagefunctionInt -> Char
ˡc̲odesfunctionInt -> Int
ˡv̲iewfunctionInt -> Char
ˡp̲icturefunctionInt -> Char
ˡl̲rsfunctionInt -> Int
ʰr̲egionsfunctionInt -> Int
svalueInt
RvalueInt
PvalueInt
dvalueInt
rowsvalueInt
colsvalueInt
alivevalueInt
trapvalueInt
crashedvalueInt
wonvalueInt
lostvalueInt
_functionUnit
_functionUnit
ᵘl̲istfunctionNum a => Int -> a
ᵘa̲rgfunction(Num a, Num b) => a -> b -> Int
ᵘt̲akeWhatfunctionNum a => a -> Int
ᵘu̲seWhatfunctionNum a => a -> Int
ᵘt̲urnfunctionNum a => Int -> a
svalueInt
_functionInt
_functionInt
ˡt̲extfunctionUnit -> Box Char
ˡk̲eysfunctionNum a => Unit -> a
ˡf̲lagsfunctionNum a => Unit -> a
ˡv̲aluesfunctionNum a => Unit -> a
ˡk̲fvfunctionNum a => Unit -> a
ˡl̲inesfunctionNum a => Int -> a -> Int
ˡs̲ayfunction(Num a, Num b) => Int -> a -> b
ˡe̲xitsfunctionNum a => Unit -> a
ˡi̲temsfunctionUnit -> Box Char
ˡh̲omesfunctionNum a => Unit -> a
ˡroomvalueInt
ˡturnsvalueInt
ˡphaservalueInt
ˡcardvalueInt
ˡtoolkitvalueInt
ˡcouplervalueInt
ˡtribblevalueInt
ˡrelayvalueInt
ˡboardersvalueInt
ˡwonvalueInt
ˡdeadvalueInt
ˡeventvalueInt
ˡn̲ewfunction(Any a, Num b) => a -> b
ˡr̲oomfunctiona -> a
ˡt̲urnsfunctiona -> a
ˡe̲ventfunctiona -> a
ˡs̲tatusfunction(Num a, Truthy a) => a -> a
ˡu̲pdatefunctionInt -> Int -> Int
ˡs̲ayingfunctionInt -> Int -> Int
ˡp̲resentfunctionNum a => a -> Int
ˡr̲efusalfunction(Truthy a, Num b) => a -> b -> b
ˡm̲ovefunctionInt -> Int -> Int
ˡg̲ofunctionInt -> Int -> Int
ˡt̲akefunctionInt -> Int -> Int
ˡu̲sefunctionInt -> Int -> Int
ˡt̲oolkitfunctionInt -> Int
ˡc̲ouplerfunctionInt -> Int
ˡt̲hrowfunctionInt -> Int
ˡf̲irefunctionInt -> Int
ˡs̲aidfunctionNum a => a -> a
ˡc̲lockfunctionInt -> Int
ˡa̲larmsfunction(Num a, Truthy a, Num b) => a -> b
svalueInt
_functionInt
takenvalueInt
_functionInt
movesvalueInt
ᵘp̲layfunctionInt -> Int -> Int
gamevalueInt
lastvalueInt
_functionInt
bayvalueInt
_functionInt
ᵘw̲aitfunctionInt -> Int
_functionInt
_functionUnit
_functionChar
_functionChar
_functionChar
_functionChar
ᵘa̲rgsfunction(Num a, Num b) => a -> b -> Int
ᵘc̲ourseAndfunctionChar -> Int
ᵘt̲urnfunctionInt -> Char
svalueInt
_functionChar
_functionChar
ˡenergyvalueInt
ˡtorpedoesvalueInt
ˡshieldsAtvalueInt
ˡstardatevalueInt
ˡquadRowvalueInt
ˡquadColvalueInt
ˡsectRowvalueInt
ˡsectColvalueInt
ˡstatusvalueInt
ˡe̲nergyfunctiona -> a
ˡt̲orpsfunctiona -> a
ˡs̲hieldsfunctiona -> a
ˡd̲atefunctiona -> a
ˡq̲uadfunctiona -> a
ˡs̲ectorfunctiona -> a
ˡs̲tatusfunctiona -> a
ˡg̲alaxyfunctiona -> Int -> a
ˡg̲ridfunctiona -> a
ˡk̲lingonsfunctionNum a => a -> a
ˡh̲erefunction(Num a, Num b, Truthy b) => a -> b
ˡu̲pdatefunctionInt -> Int -> Int
ˡp̲utfunctionInt -> Int -> Int
ˡw̲ithGridfunctionInt -> Int -> Int
ˡw̲ithPlanefunctionInt -> Int -> Int
ˡh̲omefunctionNum a => a -> a
ˡa̲tfunctionInt -> Char
ˡc̲oursesfunctionNum a => Unit -> a
ˡn̲ewfunctionAny a => a -> Int
ˡe̲nterfunctionInt -> Int
ˡs̲rsfunctionInt -> Int
ˡl̲rsfunctionInt -> Int
ˡs̲ayfunction(Any a, Any b) => a -> b -> a
ˡi̲nsufficientfunctionAny a => a -> a
ˡc̲ellfunctionNum a => a -> a
ˡm̲oveTofunctionInt -> Int -> Int
ˡp̲athfunctionInt -> Int -> Int
ˡi̲nsidefunction(Num a, Truthy b) => a -> b
ˡc̲ellsfunctionNum a => a -> a
ˡt̲rackfunctionNum a => Int -> a
ˡf̲irefunctionInt -> Int
ˡw̲arpfunctionInt -> Int -> Int
ˡc̲lampedfunctionNum a => Int -> a
ˡi̲mpulsefunctionInt -> Int -> Int
ˡc̲rossfunctionInt -> Int -> Int
ˡh̲altfunctionInt -> Int -> Int
ˡp̲hasersfunctionInt -> Int -> Int
ˡh̲itsfunctionNum a => Int -> a
ˡp̲hpfunctionInt -> Char
ˡt̲orpedofunctionInt -> Int -> Int
ˡs̲trikefunctionInt -> Int -> Int
ˡs̲hieldsTofunctionInt -> Int -> Int
ˡr̲eportfunctionInt -> Int
ˡh̲elpfunctionAny a => a -> a
ˡl̲inesfunctionNum a => Box Char -> a
ˡc̲ommandfunctionInt -> Int -> Int
ˡd̲ofunctionInt -> Int -> Int
ˡj̲udgefunctionInt -> Int
ˡe̲ndfunctionInt -> Char
ˡm̲issionfunctionInt -> Char
startvalueInt
svalueInt
PvalueInt
warpedvalueInt
foughtvalueInt
ᵘf̲arfunctionInt -> Int
latevalueInt
_functionUnit
_functionUnit
_functionChar
ᵘa̲skfunctionNum a => a -> Int
ᵘv̲erdictfunctionNum a => a -> Char
ᵘy̲oufunction(Num a, Truthy a) => a -> Char
ᵘm̲efunction(Num a, Truthy a) => a -> Char
ˡl̲inesfunctionNum a => Unit -> a
ˡs̲umsfunctionNum a => a -> a
ˡw̲innerfunction(Num a, Num b, Truthy b) => a -> b
ˡt̲urnfunction(Num a, Num b, Truthy b) => a -> b
ˡn̲ewfunction(Any a, Num b) => a -> b
ˡl̲egalfunctionNum a => a -> Int
ˡs̲tatusfunction(Num a, Num b) => a -> b
ˡm̲ovefunction(Num a, Truthy a) => a -> Int -> a
ˡc̲odesfunctionNum a => a -> Int
ˡv̲iewfunctionNum a => a -> Char
ˡp̲icturefunctionNum a => a -> Char
ˡo̲nfunctionTruthy a => Unit -> a
ˡn̲earfunction(Num a, Num b, Truthy b) => a -> a -> b
ˡa̲ifunction(Num a, Truthy a) => a -> Int
ˡv̲aluefunction(Num a, Truthy a, Num b, Truthy b) => a -> b
ˡb̲estfunction(Num a, Truthy a) => a -> Int
bvalueInt
wonvalueInt
pvalueInt
ᵘs̲elffunction(Num a, Truthy a) => a -> a
endvalueInt
_functionChar
_functionUnit
_functionUnit
_functionChar
ᵘa̲skfunctionTruthy a => a -> a
ᵘt̲urnfunctionInt -> Char
ˡn̲ewfunction(Any a, Num b) => a -> b
ˡs̲corefunctionInt -> Int
ˡs̲ubsetsfunctionUnit -> Int
ˡs̲umsfunctionUnit -> Int
ˡr̲ollfunctionInt -> Int
ˡm̲ovesfunctionInt -> Int -> Int
ˡs̲hutfunction(Num a, Truthy a, Truthy b) => a -> b -> a
ˡs̲tatusfunctionNum a => Int -> Int -> a
ˡv̲iewfunctionInt -> Char
ˡt̲ilesfunctionTruthy a => a -> Char
ˡl̲istedfunctionTruthy a => a -> Box Char
ˡh̲ighfunctionInt -> Int -> Int
MvalueInt
svalueInt
tvalueInt
ᵘg̲amefunctionInt -> Int
_functionUnit
_functionUnit
ˡnvalueInt
ˡm̲inesfunctiona -> a
ˡo̲penfunctiona -> a
ˡf̲lagsfunctiona -> a
ˡs̲tatusfunctiona -> a
ˡs̲tatefunctiona -> a -> a
ˡn̲ewfunction(Any a, Num b, Truthy b) => a -> b
ˡa̲roundfunctionNum a => a -> a
ˡc̲ountsfunctionNum a => a -> a
ˡw̲ithfunctiona -> a -> a
ˡr̲evealfunction(Num a, Truthy a) => a -> Int -> a
ˡg̲rowfunction(Num a, Truthy a) => a -> a -> a
ˡf̲lagfunction(Num a, Truthy a) => a -> Int -> a
ˡc̲odesfunction(Num a, Truthy a) => a -> a
ˡv̲iewfunctionInt -> Char
ˡp̲icturefunctionInt -> Char
svalueInt
pvalueInt
ᵘs̲tepsfunction(Num a, Truthy a) => a -> a
startvalueInt
grownvalueInt
ᵘc̲learfunction(Num a, Truthy a) => a -> Int -> a
donevalueInt
_functionChar
_functionUnit
_functionUnit
_functionChar
ᵘa̲skfunctionAny a => a -> Int
ᵘt̲urnfunctionInt -> Char
bvalueInt
ᵘp̲ickfunction(Num a, Truthy a, Num b) => a -> b
ᵘg̲amefunction(Num a, Truthy a) => a -> a
endvalueInt
_functionUnit
_functionUnit
ˡs̲corefunctiona -> a
ˡb̲oardfunctiona -> a
ˡc̲ompressfunction(Num a, Truthy a) => a -> a
ˡp̲lacefunctionNum a => a -> Int
ˡd̲oublesfunction(Num a, Truthy b) => a -> b
ˡm̲ergefunction(Num a, Truthy a) => a -> a
ˡl̲eftfunction(Num a, Truthy a) => a -> a
ˡt̲urnfunctionNum b => a -> b -> a
ˡb̲ackfunctionNum b => a -> b -> a
ˡs̲lidefunction(Num a, Truthy a, Num b) => a -> b -> a
ˡg̲ainfunction(Num a, Truthy a, Num b) => a -> b -> a
ˡs̲pawnfunction(Num a, Truthy a) => a -> a
ˡn̲ewfunction(Any a, Num b, Truthy b) => a -> b
ˡm̲ovefunction(Num a, Truthy a, Num b) => a -> b -> a
ˡs̲tatusfunction(Num a, Truthy a, Num b) => a -> b
_functionChar
ᵘa̲skfunctionAny a => a -> Int
ᵘt̲urnfunction(Num a, Truthy a) => a -> Char
ᵘs̲tuckfunction(Num a, Truthy a) => a -> a
_functionChar
ᵘp̲uzzlefunctionUnit -> Int
ᵘb̲adPuzzlefunctionInt -> Char
ᵘr̲efusedfunctionNum a => a -> b -> Char
ᵘh̲intfunctionInt -> Char
ᵘc̲ellfunctionInt -> Int -> Char
ᵘt̲urnfunctionInt -> Char
ᵘa̲skfunctionInt -> Char
ᵘs̲ayfunctionInt -> Char -> Char
ᵘs̲olutionfunctionInt -> Char
jvalueInt
cellvalueInt
ˡu̲nitsfunctionUnit -> Int
ˡh̲omesfunctionUnit -> Int
ˡo̲nehotfunction(Num a, Truthy a) => Int -> a
ˡp̲erUnitfunctionNum a => a -> a
ˡp̲erCellfunctionNum a => a -> a
ˡc̲andidatesfunction(Num a, Truthy a) => Int -> a
ˡs̲inglesfunction(Num a, Num b, Num c, Truthy c) => a -> b -> c
ˡr̲oundfunctionInt -> Int
ˡp̲ropagatefunctionInt -> Int
ˡb̲rokenfunction(Num a, Num b, Truthy b) => Int -> a -> b
ˡs̲olvefunctionInt -> Int
ˡt̲ryfunctionInt -> Int -> Int
ˡr̲oundsfunctionNum a => Int -> a
ˡc̲ellsfunctionChar -> Int
ˡp̲uzzlesfunctionUnit -> Int
ˡp̲roblemfunctionNum a => Int -> a
ˡn̲ewfunctionInt -> Int
ʰg̲amefunctionInt -> Int
ˡg̲ivensfunctiona -> a
ˡg̲ridfunctiona -> a
ˡw̲hyfunctionNum a => Int -> Int -> a
ˡc̲lashfunctionNum a => Int -> Int -> a
ˡm̲ovefunctionInt -> Int -> Int
ˡl̲egalfunction(Num a, Truthy a) => Int -> a
ˡs̲tatusfunction(Num a, Truthy a) => Int -> a
ˡh̲intfunctionInt -> Int
ˡs̲hownfunctionInt -> Char
ˡv̲iewfunctionInt -> Char
gvalueInt
UvalueInt
cvalueInt
hvalueInt
kvalueInt
xvalueInt
svalueInt
ownvalueInt
_functionUnit
_functionUnit
rowvalueInt
colvalueInt
ˡp̲ressesfunction(Num a, Truthy a) => Unit -> a
ˡa̲fterfunctionInt -> Int -> Int
ʰs̲tepfunctionInt -> (Int, Int) -> Int
ˡs̲olvefunctionInt -> Int
ˡn̲ewfunctionAny a => a -> Int
ˡm̲ovesfunctiona -> a
ˡl̲ightsfunctiona -> a
ˡp̲ressfunctionInt -> Int -> Int
ˡh̲intfunctionInt -> Int
ˡs̲tatusfunction(Num a, Num b, Truthy b) => a -> b
viewvalueFloat
ˡs̲quaresfunctionUnit -> Float
ˡc̲lickfunctionInt -> Float -> Int
ˡs̲ayfunctionNum a => a -> Char
ʰc̲ountfunctionNum a => a -> Char
ʰf̲illfunctionInt -> Char
ˡd̲rawfunctionInt -> Char
PvalueInt
svalueInt
xvalueInt
qvalueInt
tvalueInt
ᵘp̲ressAllfunctionInt -> Int -> Int
donevalueInt
_functionChar
_functionUnit
_functionUnit
_functionUnit
ᵘl̲oopfunctionInt -> Char
allvalueBox Char
townsvalueBox Char
ʰc̲ityfunctionBox Char -> Char
namesvalueBox Char
latvalueFloat
lonvalueFloat
regionsvalueBox Char
regionvalueInt
tlatvalueFloat
tlonvalueFloat
landvalueChar
ˡm̲xfunctionNum a => a -> a
ˡm̲yfunctionNum a => a -> a
ˡp̲oolfunctionInt -> Int
ˡr̲egionsfunctionUnit -> Box Char
ˡa̲tfunctionInt -> Float
ˡn̲amefunctionInt -> Char
ˡv̲iewfunctionInt -> Float
ˡc̲losefunctionInt -> Float
ˡt̲ownfunctionInt -> Char
ˡc̲hoicesfunctionInt -> Int
ˡa̲nswerfunctionInt -> Int
ˡn̲ewfunctionInt -> Int
ˡs̲corefunctiona -> a
ˡd̲otsfunctionInt -> Int
ˡr̲esultsfunctionInt -> Int
ˡs̲tatusfunction(Num a, Truthy a) => Int -> a
ˡm̲enufunctionInt -> Float
ʰd̲otfunctionInt -> Float -> Int
ˡc̲lickfunctionInt -> Float -> Int
ʰo̲penfunctionInt -> Float -> Int
ʰs̲etfunction(Int, Int) -> Int -> Int
ʰa̲nswerfunctionInt -> Int -> Int
ʰr̲oundOverfunctionInt -> Char
ˡs̲ayfunctionInt -> Char
ʰd̲otColorfunctionInt -> Char
ʰs̲potsfunctionInt -> Float -> Box Char
ʰb̲arfunctionInt -> Float -> Box Char
ʰs̲aidfunctionInt -> Float -> Box Char
ʰc̲hoosefunctionInt -> Box Char
ˡd̲rawfunctionInt -> Char
pvalueInt
svalueInt
_functionChar
ivalueInt
askedvalueInt
kvalueInt
bvalueFloat
answeredvalueInt
_functionChar
_functionUnit
_functionUnit
ᵘl̲oopfunctionInt -> Char
ᵘl̲oopfunctionInt -> Char
namedvalueBox Char
namesvalueBox Char
ravalueFloat
decvalueFloat
magvalueFloat
ʰs̲econdfunctionBox Char -> Float
ʰt̲hirdfunctionBox Char -> Float
partsvalueBox Char
ra0valueFloat
ra1valueFloat
dec0valueFloat
dec1valueFloat
edgesvalueFloat
bandvalueInt
mixvalueInt
skyvalueBox Char
sxvalueFloat
syvalueFloat
classvalueInt
ʰp̲ointsfunctionInt -> Char
ʰw̲idthfunctionInt -> Char
layervalueChar
ˡs̲xfunctionNum a => a -> a
ˡs̲yfunctionNum a => a -> a
ʰi̲nRafunctionTruthy a => Int -> a
ˡp̲oolfunctionInt -> Int
ˡp̲artsfunctionUnit -> Box Char
ˡn̲amefunctionInt -> Char
ˡv̲iewfunctionInt -> Float
ˡa̲tfunctionInt -> Int -> Float
ˡc̲hoicesfunctionInt -> Int -> Int
ʰo̲nefunctionInt -> (Int, Int) -> Int
ʰu̲pTofunctionInt -> a -> a
ˡn̲ewfunctionInt -> Int
ˡs̲corefunctiona -> a
ˡm̲arksfunctionInt -> Int
ˡr̲esultsfunctionInt -> Int
ˡs̲tatusfunction(Num a, Truthy a) => Int -> a
ˡo̲fferedfunctionInt -> Int
ˡm̲enufunctionInt -> Float
ʰx̲sfunctionInt -> Float
ʰy̲sfunctionInt -> Float
ʰs̲tarAtfunctionInt -> Float -> Int
ˡc̲lickfunctionInt -> Float -> Int
ʰo̲penfunctionInt -> Float -> Int
ʰs̲etfunction(Int, Int) -> Int -> Int
ʰa̲nswerfunctionInt -> Int -> Int
ʰr̲oundOverfunctionInt -> Char
ˡs̲ayfunctionInt -> Char
ʰr̲ingColorfunctionInt -> Char
ʰr̲ingsfunctionInt -> Float -> Box Char
ʰb̲arfunctionInt -> Float -> Box Char
ʰs̲aidfunctionInt -> Float -> Box Char
ʰc̲hoosefunctionInt -> Box Char
ˡd̲rawfunctionInt -> Char
ivalueInt
svalueInt
_functionChar
jvalueInt
askedvalueInt
cvalueInt
bvalueFloat
answeredvalueInt
_functionChar
_functionUnit
_functionUnit
ʰw̲orldfunctionInt -> Float
ʰp̲osfunctiona -> a
ʰh̲asPosfunction(Num a, Truthy b) => a -> b
ʰs̲etPosfunctionFloat -> (Int, Float) -> Float
ʰd̲ropPosfunctionFloat -> Int -> Float
ʰh̲pfunctiona -> a
ʰh̲asHpfunction(Num a, Truthy b) => a -> b
ʰs̲etHpfunctionFloat -> (Int, Float) -> Float
ʰd̲ropHpfunctionFloat -> Int -> Float
ʰa̲tkfunctiona -> a
ʰh̲asAtkfunction(Num a, Truthy b) => a -> b
ʰs̲etAtkfunctionFloat -> (Int, Float) -> Float
ʰd̲ropAtkfunctionFloat -> Int -> Float
ʰk̲indfunctiona -> a
ʰh̲asKindfunction(Num a, Truthy b) => a -> b
ʰs̲etKindfunctionFloat -> (Int, Float) -> Float
ʰd̲ropKindfunctionFloat -> Int -> Float
ʰc̲hasefunctiona -> a
ʰh̲asChasefunction(Num a, Truthy b) => a -> b
ʰs̲etChasefunctionFloat -> (Int, Float) -> Float
ʰd̲ropChasefunctionFloat -> Int -> Float
ʰh̲ealfunctiona -> a
ʰh̲asHealfunction(Num a, Truthy b) => a -> b
ʰs̲etHealfunctionFloat -> (Int, Float) -> Float
ʰd̲ropHealfunctionFloat -> Int -> Float
ʰg̲oldfunctiona -> a
ʰh̲asGoldfunction(Num a, Truthy b) => a -> b
ʰs̲etGoldfunctionFloat -> (Int, Float) -> Float
ʰd̲ropGoldfunctionFloat -> Int -> Float
ʰp̲layerfunctiona -> a
ʰh̲asPlayerfunction(Num a, Truthy b) => a -> b
ʰs̲etPlayerfunctionFloat -> (Int, Float) -> Float
ʰd̲ropPlayerfunctionFloat -> Int -> Float
ʰg̲oalfunctiona -> a
ʰh̲asGoalfunction(Num a, Truthy b) => a -> b
ʰs̲etGoalfunctionFloat -> (Int, Float) -> Float
ʰd̲ropGoalfunctionFloat -> Int -> Float
ʰf̲irstCharfunctionBox a -> a
ʰc̲olumnfunctionInt -> Float
cellsvalueChar
mapsvalueInt
ʰg̲ridfunctionInt -> Char
ʰw̲allsfunctionTruthy a => Int -> a
kindsvalueBox Char
glyphsvalueChar
colorsvalueBox Char
youvalueFloat
HPvalueFloat
ATvalueFloat
CHvalueFloat
HEvalueFloat
GOvalueFloat
ʰs̲tepsfunctionInt -> Int -> Int
ˡn̲ewfunction(Any a, Num b, Num c) => a -> (Float, b, c, Char, Int)
ʰp̲utSomefunctionNum a => Float -> (Int, Int, Float, a) -> Float
ʰs̲ignfunction(Num a, Num b, Truthy b) => a -> b
ʰc̲ellfunctionNum a => a -> Int
ʰa̲tfunction(Eq a, Truthy b) => a -> a -> b
ʰf̲oesfunctionNum a => a -> Int
ʰm̲efunctionNum a => a -> Int
ˡt̲urnfunction(Num a, Any b) => (Float, Int, a, b, Int) -> Float -> (Float, Int, a, Char, Int)
ʰy̲oufunctionTruthy a => (Float, Int, Float, Int, a) -> (Float, Char)
ʰp̲ickUpfunction(Float, Int, Int) -> (Float, Int, Box Char)
ʰb̲eatenfunction(Float, Int) -> (Float, Int, Box Char)
ʰm̲onstersfunction(Float, Int, Int) -> (Float, Char)
ʰo̲uchfunctionFloat -> Char
ˡs̲tatusfunction(Num a, Any b, Any c, Any d, Any e, Num f) => (a, b, c, d, e) -> f
ˡy̲oufunction(Num a, Any b, Any c) => (a, Int, Int, b, c) -> Int
ʰf̲illfunctionChar -> Char
ʰs̲quarefunction(Float, Float, Char) -> Box Char
ʰl̲ayerfunctionInt -> Char
layersvalueBox Char
ʰg̲lyphfunctionInt -> Char
ʰc̲olorfunctionInt -> Char
ʰe̲ntityfunctionTruthy a => (Float, Float, Int, a) -> Char
ˡd̲rawfunction(Float, Int, Int, a, Int) -> Char
ˡh̲asfunction(Num a, Any b, Any c, Any d, Any e, Num f, Truthy f) => (a, b, c, d, e) -> f
startvalue(Float, Int, Int, Char, Int)
WvalueFloat
ᵘw̲alkfunctionNum a => (Float, Int, a, Char, Int) -> Float -> (Float, Int, a, Char, Int)
walkedvalue(Float, Int, Int, Char, Int)
mvalueChar
_functionChar
ᵘw̲orldfunction(Any a, Any b, Any c, Any d, Any e) => (a, b, c, d, e) -> a
_functionUnit
_functionUnit
ᵘs̲tepfunction(Num a, Truthy a) => Char -> a
ᵘl̲oopfunction(Float, Int, Int, Char, Int) -> Char
ᵘe̲ndfunction(Float, Int, Int, Char, Int) -> Char
svalue(Int, Int, Int, Int, Bool, Int, Int)
ᵘp̲ressfunction(Num a, Truthy b, Num c, Any d) => (Int, Int, Int, a, b, c, d) -> Char -> (Int, Int, Int, a, b, c, d)
walkedvalue(Int, Int, Int, Int, Bool, Int, Int)
_functionChar
tvalue(Int, Int, Int, Int, Bool, Int, Int)
_functionUnit
_functionUnit
sizevalueInt
CWvalueInt
CHvalueInt
BvalueInt
BHvalueInt
NBvalueInt
WALLSvalueBox Char
FLOORvalueChar
CEILINGvalueChar
STEPSvalueInt
FARvalueInt
ʰc̲arvefunction(Any a, Truthy b) => a -> b
ʰs̲hiftfunctionInt -> Int -> Int
ʰf̲loodfunction(Int, Int) -> Int
ˡn̲ewfunction(Any a, Num b, Num c, Truthy d, Num e) => a -> (Int, Int, b, c, d, e, Int)
ʰw̲allfunctionTruthy a => (Int, Int) -> a
ʰl̲ookfunction(Int, Int) -> (Int, Int, Int)
ʰd̲epthfunction(Int, Int) -> Int
ʰs̲eefunction(Truthy a, Truthy b) => (Int, Int, Int, a) -> b
ʰm̲ovedfunction(Num a, Truthy b, Any c, Any d) => (Int, Int, Int, Int, a, b, c, d) -> (Int, Int, Int, a, b, c, d)
ˡk̲eyfunction(Num a, Truthy b, Num c, Any d) => (Int, Int, Int, a, b, c, d) -> Char -> (Int, Int, Int, a, b, c, d)
ˡs̲tatusfunction(Any a, Eq b, Any c, Any d, Any e, Any f, Num g, Truthy g) => (a, b, c, d, e, f, b) -> g
ˡy̲oufunction(Any a, Any c, Any d) => (a, b, b, b, c, d, b) -> b
ˡg̲ridfunction(Num a, Any b, Any c, Any d, Any e, Any f, Any g) => (a, b, c, d, e, f, g) -> a
ˡd̲istancesfunction(Any a, Any b, Any c, Any d, Any e) => (Int, Int, a, b, c, d, e) -> Int
ˡs̲eenfunction(Any a, Any b, Any c, Any d, Num e, Any f, Any g) => (a, b, c, d, e, f, g) -> e
HvalueFloat
VvalueFloat
CXvalueFloat
CYvalueFloat
ʰc̲olorfunctionInt -> Char
ʰs̲idefunction(Truthy a, Truthy b) => (Int, Float, a, b) -> Char
ʰf̲rontfunctionInt -> Char
ʰd̲oorfunctionInt -> Char
ʰv̲iewfunction(Int, Int, Int, Int) -> Box Char
ʰb̲lockfunction(Int, Int, Int, Float, Float) -> Box Char
ʰm̲apfunction(Num a, Truthy b) => (Int, Int, a, b, Int) -> Box Char
ʰm̲apIffunction(Num a, Truthy b, Num c) => (Int, Int, a, b, Int, c) -> Box Char
ʰs̲aysfunction(Num b, Any c) => (a, Int, b, c) -> Char
ˡd̲rawfunction(Truthy b, Num c) => (Int, Int, Int, a, b, c, Int) -> Char
ᵘs̲howfunction(Truthy a, Num b) => (Int, Int, Int, Int, a, b, Int) -> Char
ᵘl̲oopfunction(Truthy a, Num b) => (Int, Int, Int, Int, a, b, Int) -> Char
ᵘe̲ndfunction(Truthy a, Num b) => (Int, Int, Int, Int, a, b, Int) -> Char
ʰw̲orldfunctionInt -> Float
ʰp̲osfunctiona -> a
ʰh̲asPosfunction(Num a, Truthy b) => a -> b
ʰs̲etPosfunctionFloat -> (Int, Float) -> Float
ʰd̲ropPosfunctionFloat -> Int -> Float
ʰv̲elfunctiona -> a
ʰh̲asVelfunction(Num a, Truthy b) => a -> b
ʰs̲etVelfunctionFloat -> (Int, Float) -> Float
ʰd̲ropVelfunctionFloat -> Int -> Float
ʰb̲odyfunctiona -> a
ʰh̲asBodyfunction(Num a, Truthy b) => a -> b
ʰs̲etBodyfunctionFloat -> (Int, Float) -> Float
ʰd̲ropBodyfunctionFloat -> Int -> Float
ʰw̲alkerfunctiona -> a
ʰh̲asWalkerfunction(Num a, Truthy b) => a -> b
ʰs̲etWalkerfunctionFloat -> (Int, Float) -> Float
ʰd̲ropWalkerfunctionFloat -> Int -> Float
ʰc̲oinfunctiona -> a
ʰh̲asCoinfunction(Num a, Truthy b) => a -> b
ʰs̲etCoinfunctionFloat -> (Int, Float) -> Float
ʰd̲ropCoinfunctionFloat -> Int -> Float
ʰp̲layerfunctiona -> a
ʰh̲asPlayerfunction(Num a, Truthy b) => a -> b
ʰs̲etPlayerfunctionFloat -> (Int, Float) -> Float
ʰd̲ropPlayerfunctionFloat -> Int -> Float
ʰg̲oalfunctiona -> a
ʰh̲asGoalfunction(Num a, Truthy b) => a -> b
ʰs̲etGoalfunctionFloat -> (Int, Float) -> Float
ʰd̲ropGoalfunctionFloat -> Int -> Float
rowsvalueBox Char
cellsvalueChar
RvalueInt
CvalueInt
solidvalueBool
physvalueFloat
GRAVITYvalueFloat
JUMPvalueFloat
RUNvalueFloat
WALKvalueFloat
FALLvalueFloat
KEEPvalueFloat
SIZEvalueFloat
ʰp̲airfunction(a, a) -> a
ˡn̲ewfunction(Any a, Num b, Num c) => a -> (Float, b, Float, c)
ʰs̲olidfunctionTruthy a => (Int, Int) -> a
ʰb̲odiesfunctionNum a => a -> Int
ʰm̲efunctionNum a => a -> Int
ʰg̲ravityfunctionFloat -> Float -> Float
ʰs̲lowfunctionFloat -> Float
ʰa̲crossfunctionFloat -> Float -> Float
ʰd̲ownfunctionFloat -> Float -> Float
ʰt̲ouchingfunctionFloat -> (Int, Float) -> Int
ʰa̲nyfunction(Num a, Truthy b) => a -> b
ʰo̲utcomefunction(Truthy a, Truthy b, Num c) => (a, b) -> c
ʰt̲ouchfunctionNum a => Float -> Int -> (Float, Int, a)
ˡt̲ickfunctionNum a => (Float, Int, Float, a) -> Float -> (Float, Int, Float, a)
ʰs̲tanding?functionTruthy a => Float -> Int -> a
ˡk̲eyfunction(Any a, Any b, Num c) => (Float, a, b, c) -> Char -> (Float, a, b, c)
ˡs̲tatusfunction(Any a, Any b, Any c, Any d) => (a, b, c, d) -> d
ˡc̲ountsfunction(Num a, Any b, Any c, Any d, Num e, Truthy e) => (a, b, c, d) -> e
ˡb̲odiesfunction(Num a, Any b, Any c, Any d) => (a, b, c, d) -> a
ˡy̲oufunction(Num a, Any b) => (Float, a, Float, b) -> Float
ʰt̲ilefunctionInt -> Box Char
levelvalueChar
ʰs̲pritefunctionNum a => (Float, Float, a) -> Char
ʰs̲aysfunction(Num b, Num c) => (a, b, c) -> Char
ˡd̲rawfunction(Num b, Num c) => (Float, a, b, c) -> Char
ᵘs̲howfunctionNum a => (Float, Int, Float, a) -> Char
ᵘl̲oopfunctionNum a => (Float, Int, Float, a) -> Char
ᵘe̲ndfunctionNum a => (Float, Int, Float, a) -> Char
startvalue(Float, Int, Float, Int)
WvalueFloat
gvalueInt
tvalueFloat
stvalueInt
ᵘr̲unfunction(Num a, Num b) => (Float, Int, Float, a) -> b -> (Float, Int, Float, a)
ranvalue(Float, Int, Float, Int)
ᵘh̲eightfunction(Num a, Any b) => (Float, a, Float, b) -> Float
ᵘa̲irfunction(Num a, Num b) => (Float, Int, Float, a) -> b -> Float
upvalue(Float, Int, Float, Int)
yvalueFloat
_functionChar
_functionUnit
_functionUnit
_functionUnit
TvalueInt
wvalueInt
startvalue(Int, Int, Int, Int, Int, Int, Int, Int, Float, Float, Int)
ᵘw̲aitfunction(Num a, Num b) => (Int, Int, Int, Int, Int, Int, Int, Int, Float, Float, a) -> b -> (Int, Int, Int, Int, Int, Int, Int, Int, Float, Float, a)
waitedvalue(Int, Int, Int, Int, Int, Int, Int, Int, Float, Float, Int)
ᵘp̲ressfunction(Any a, Num b) => (Int, Int, Int, Int, Int, Int, Int, Int, Float, a, b) -> Char -> (Int, Int, Int, Int, Int, Int, Int, Int, Float, a, b)
droppedvalue(Int, Int, Int, Int, Int, Int, Int, Int, Float, Float, Int)
ᵘa̲utofunction(Any a, Num b, Num c) => (Int, Int, Int, Int, Int, Int, Int, Int, Float, a, b) -> c -> (Int, Int, Int, Int, Int, Int, Int, Int, Float, a, b)
latervalue(Int, Int, Int, Int, Int, Int, Int, Int, Float, Float, Int)
_functionChar
_functionUnit
_functionUnit
_functionUnit
ʰn̲umsfunctionChar -> Float
namesvalueBox Char
colorsvalueBox Char
wellvalueInt
WIDEvalueInt
DEEPvalueInt
speedvalueFloat
PERvalueInt
POINTSvalueInt
ʰr̲eadfunction(Num a, Truthy a) => Int -> a
SHAPESvalueBox Int
ʰs̲hapefunctionInt -> Int
ʰc̲ellsfunctionNum a => (a, Int, Int) -> (Int, Int)
ʰf̲itsfunction(Num a, Num b, Truthy c) => (a, b, Int, Int) -> c
ʰl̲andingfunction(Num a, Num b) => (a, b, Int, Int) -> Int
ʰl̲eavefunction(Num a, Truthy a, Num b) => (a, b, a, Int, Int) -> a
ˡc̲learfunctionNum a => a -> a
ʰf̲ullfunction(Num a, Num b, Truthy b) => a -> b
ʰl̲evelfunctionInt -> Int
ʰp̲ausefunctionInt -> Float
ʰo̲verfunction(Truthy a, Num b) => a -> b
ʰn̲extfunction(Num a, Any b, Any c, Any d, Num e, Num f) => (a, Int, b, c, d) -> (a, Int, Int, e, Int, Int, b, c, Float, d, f)
ˡn̲ewfunction(Any a, Num b, Num c, Num d, Num e, Num f) => a -> (b, Int, Int, c, Int, Int, d, e, Float, Float, f)
ʰs̲ettlefunction(Num a, Truthy a, Num b, Any c, Any d, Any e, Num f, Num g) => (a, b, a, Int, Int, Int, Int, Int, c, d, e) -> (a, Int, Int, f, Int, Int, Int, Int, Float, d, g)
ʰd̲ownfunction(Any a, Num b) => (Int, Int, Int, Int, Int, Int, Int, Int, Float, a, b) -> (Int, Int, Int, Int, Int, Int, Int, Int, Float, a, b)
ˡt̲ickfunctionNum a => (Int, Int, Int, Int, Int, Int, Int, Int, Float, Float, a) -> Float -> (Int, Int, Int, Int, Int, Int, Int, Int, Float, Float, a)
ˡt̲urnfunctiona -> a
ʰt̲urnedfunction(Num a, Num b, Any c, Any d, Any e, Any f, Any g, Any h, Any i) => (a, b, c, Int, Int, d, e, f, g, h, i) -> (a, b, c, Int, Int, d, e, f, g, h, i)
ʰs̲lidfunction(Num a, Num b, Any c, Any d, Any e, Any f, Any g, Any h, Any i) => (a, b, c, Int, Int, d, e, f, g, h, i) -> Int -> (a, b, c, Int, Int, d, e, f, g, h, i)
ʰd̲roppedfunction(Num a, Truthy a, Num b, Any c, Any d, Any e, Num f, Num g) => (a, b, a, Int, Int, Int, Int, Int, c, d, e) -> (a, Int, Int, f, Int, Int, Int, Int, Float, d, g)
ʰt̲urnsfunction(Num a, Num b, Any c, Any d, Any e, Any f, Any g, Any h, Any i, Num j) => (a, b, c, Int, Int, d, e, f, g, h, i) -> j -> (a, b, c, Int, Int, d, e, f, g, h, i)
ʰs̲lidesfunction(Num a, Num b, Any c, Any d, Any e, Any f, Any g, Any h, Any i, Num j, Truthy j) => (a, b, c, Int, Int, d, e, f, g, h, i) -> j -> (a, b, c, Int, Int, d, e, f, g, h, i)
ʰa̲fterfunction(Num a, Truthy a, Num b, Any c, Any d, Any e, Num f, Num g, Truthy g, Num h, Num i) => (a, b, a, Int, Int, Int, Int, Int, c, d, e) -> (f, g) -> (a, Int, Int, h, Int, Int, Int, Int, Float, d, i)
ʰw̲orthfunction(Num a, Num b) => (a, b) -> Float
ʰv̲aluefunction(Any a, Num b) => (Int, Int, Int, Int, Int, Int, Int, Int, Float, a, b) -> (Int, Int) -> Float
ˡa̲ifunction(Any a, Num b) => (Int, Int, Int, Int, Int, Int, Int, Int, Float, a, b) -> (Int, Int)
ˡk̲eyfunction(Any a, Num b) => (Int, Int, Int, Int, Int, Int, Int, Int, Float, a, b) -> Char -> (Int, Int, Int, Int, Int, Int, Int, Int, Float, a, b)
ˡs̲tatusfunction(Any a, Any b, Any c, Any d, Any e, Any f, Any g, Any h, Any i, Any j, Any k) => (a, b, c, d, e, f, g, h, i, j, k) -> k
ˡs̲corefunction(Any a, Num b) => (Int, Int, Int, Int, Int, Int, Int, Int, Float, a, b) -> Int
ˡw̲ellfunction(Num a, Truthy a, Num b, Any c, Any d, Any e, Any f, Any g, Any h) => (a, b, a, Int, Int, c, d, e, f, g, h) -> a
ˡp̲iecefunction(Any a, Any b, Any c, Any e, Any f, Any g, Any h, Any i, Any j) => (a, b, c, d, d, e, f, g, h, i, j) -> (b, d, e)
CELLvalueFloat
X0valueFloat
Y0valueFloat
ʰf̲illfunctionNum a => (Char, a) -> Char
ʰb̲lockfunction(Num a, Num b, Num c) => (a, b, Int, Float, Float, c) -> Box Char
ʰb̲locksfunction(Num a, Num b, Num c) => (a, b, Int, Float, Float, c) -> Box Char
ʰs̲ettledfunctionInt -> Box Char
ʰs̲aysfunction(Num b, Num c) => (a, Int, b, c) -> Char
ˡd̲rawfunction(Num a, Any c, Num d, Num e) => (Int, a, Int, Int, Int, Int, b, Int, c, d, e) -> Char
ᵘs̲howfunctionNum a => (Int, Int, Int, Int, Int, Int, Int, Int, Float, Float, a) -> Char
ᵘl̲oopfunctionNum a => (Int, Int, Int, Int, Int, Int, Int, Int, Float, Float, a) -> Char
ᵘq̲uitfunctionNum a => (Int, Int, Int, Int, Int, Int, Int, Int, Float, Float, a) -> Char
ᵘe̲ndfunctionNum a => (Int, Int, Int, Int, Int, Int, Int, Int, Float, Float, a) -> Char
ᵘs̲howfunction(Num a, Num b, Truthy b) => (Float, Float, a, b) -> Char
ᵘl̲oopfunction(Num a, Num b, Truthy b) => (Float, Float, a, b) -> Char
ᵘe̲ndfunction(Num a, Num b, Truthy b) => (Float, Float, a, b) -> Char
ʰw̲orldfunctionInt -> Float
ʰp̲osfunctiona -> a
ʰh̲asPosfunction(Num a, Truthy b) => a -> b
ʰs̲etPosfunctionFloat -> (Int, Float) -> Float
ʰd̲ropPosfunctionFloat -> Int -> Float
ʰd̲irfunctiona -> a
ʰh̲asDirfunction(Num a, Truthy b) => a -> b
ʰs̲etDirfunctionFloat -> (Int, Float) -> Float
ʰd̲ropDirfunctionFloat -> Int -> Float
ʰs̲peedfunctiona -> a
ʰh̲asSpeedfunction(Num a, Truthy b) => a -> b
ʰs̲etSpeedfunctionFloat -> (Int, Float) -> Float
ʰd̲ropSpeedfunctionFloat -> Int -> Float
ʰt̲opfunctiona -> a
ʰh̲asTopfunction(Num a, Truthy b) => a -> b
ʰs̲etTopfunctionFloat -> (Int, Float) -> Float
ʰd̲ropTopfunctionFloat -> Int -> Float
ʰn̲extfunctiona -> a
ʰh̲asNextfunction(Num a, Truthy b) => a -> b
ʰs̲etNextfunctionFloat -> (Int, Float) -> Float
ʰd̲ropNextfunctionFloat -> Int -> Float
ʰl̲apfunctiona -> a
ʰh̲asLapfunction(Num a, Truthy b) => a -> b
ʰs̲etLapfunctionFloat -> (Int, Float) -> Float
ʰd̲ropLapfunctionFloat -> Int -> Float
ʰp̲layerfunctiona -> a
ʰh̲asPlayerfunction(Num a, Truthy b) => a -> b
ʰs̲etPlayerfunctionFloat -> (Int, Float) -> Float
ʰd̲ropPlayerfunctionFloat -> Int -> Float
ʰp̲aintfunctiona -> a
ʰh̲asPaintfunction(Num a, Truthy b) => a -> b
ʰs̲etPaintfunctionFloat -> (Int, Float) -> Float
ʰd̲ropPaintfunctionFloat -> Int -> Float
XvalueFloat
YvalueFloat
NvalueInt
BXvalueFloat
BYvalueFloat
WIDTHvalueFloat
colorsvalueBox Char
TOPSvalueFloat
racevalueFloat
LAPSvalueFloat
GOvalueFloat
FASTvalueFloat
ACCELvalueFloat
TURNvalueFloat
KEEPvalueFloat
STEERvalueFloat
GRASSvalueFloat
NEARvalueFloat
ʰp̲airfunction(a, a) -> a
ˡn̲ewfunction(Any a, Num b, Num c) => a -> (Float, Float, b, c)
ʰc̲arsfunctionNum a => a -> Int
ʰm̲efunctionNum a => a -> Int
ʰt̲argetfunctionNum a => a -> Int -> Float
ʰo̲ffLinefunctionFloat -> Float
ʰd̲rivefunctionFloat -> Float -> Float
ʰm̲ovefunctionFloat -> Float -> Float
ʰp̲assfunctionFloat -> Float
ʰp̲rogressfunctionFloat -> Float
ʰp̲lacesfunction(Num a, Truthy a) => Float -> a
ʰf̲inishfunction(Any a, Any b, Any c, Num d, Num e, Truthy e) => (Float, a, b, c) -> (Float, a, d, e)
ˡt̲ickfunction(Num a, Num b, Truthy b) => (Float, Float, a, b) -> Float -> (Float, Float, a, b)
ˡk̲eyfunction(Num a, Any b) => (Float, Float, a, b) -> Char -> (Float, Float, a, b)
ˡs̲tatusfunction(Any a, Any b, Any c, Any d) => (a, b, c, d) -> c
ˡp̲lacefunction(Any a, Any b, Any c, Any d) => (a, b, c, d) -> d
ˡy̲oufunction(Any a, Any b) => (Float, Float, a, b) -> Float
ˡc̲arfunction(Any a, Any b, Any c) => (Float, a, b, c) -> Float
ˡc̲arsfunction(Any a, Any b, Any c) => (Float, a, b, c) -> Float
roadvalueChar
trackvalueChar
ʰc̲arfunction(Float, Float, Float, Int, Int) -> Char
ʰs̲aysfunction(Num a, Num b) => (a, Float, b, c, d) -> Char
ˡd̲rawfunctionNum a => (Float, Float, a, b) -> Char
startvalue(Float, Float, Int, Int)
WvalueFloat
tvalueFloat
stvalueInt
plvalueInt
ᵘw̲aitfunction(Num a, Num b, Truthy b, Num c) => (Float, Float, a, b) -> c -> (Float, Float, a, b)
latervalue(Float, Float, Int, Int)
spedvalue(Float, Float, Int, Int)
movedvalue(Float, Float, Int, Int)
_functionChar
ᵘw̲orldfunction(Any a, Any b, Any c, Any d) => (a, b, c, d) -> a
_functionUnit
_functionUnit
_functionUnit
ʰw̲orldfunctionInt -> Float
ʰp̲osfunctiona -> a
ʰh̲asPosfunction(Num a, Truthy b) => a -> b
ʰs̲etPosfunctionFloat -> (Int, Float) -> Float
ʰd̲ropPosfunctionFloat -> Int -> Float
ʰk̲indfunctiona -> a
ʰh̲asKindfunction(Num a, Truthy b) => a -> b
ʰs̲etKindfunctionFloat -> (Int, Float) -> Float
ʰd̲ropKindfunctionFloat -> Int -> Float
ʰl̲evelfunctiona -> a
ʰh̲asLevelfunction(Num a, Truthy b) => a -> b
ʰs̲etLevelfunctionFloat -> (Int, Float) -> Float
ʰd̲ropLevelfunctionFloat -> Int -> Float
ʰp̲rogfunctiona -> a
ʰh̲asProgfunction(Num a, Truthy b) => a -> b
ʰs̲etProgfunctionFloat -> (Int, Float) -> Float
ʰd̲ropProgfunctionFloat -> Int -> Float
ʰh̲pfunctiona -> a
ʰh̲asHpfunction(Num a, Truthy b) => a -> b
ʰs̲etHpfunctionFloat -> (Int, Float) -> Float
ʰd̲ropHpfunctionFloat -> Int -> Float
ʰs̲lowfunctiona -> a
ʰh̲asSlowfunction(Num a, Truthy b) => a -> b
ʰs̲etSlowfunctionFloat -> (Int, Float) -> Float
ʰd̲ropSlowfunctionFloat -> Int -> Float
ʰc̲oolfunctiona -> a
ʰh̲asCoolfunction(Num a, Truthy b) => a -> b
ʰs̲etCoolfunctionFloat -> (Int, Float) -> Float
ʰd̲ropCoolfunctionFloat -> Int -> Float
ʰt̲argetfunctiona -> a
ʰh̲asTargetfunction(Num a, Truthy b) => a -> b
ʰs̲etTargetfunctionFloat -> (Int, Float) -> Float
ʰd̲ropTargetfunctionFloat -> Int -> Float
ʰd̲mgfunctiona -> a
ʰh̲asDmgfunction(Num a, Truthy b) => a -> b
ʰs̲etDmgfunctionFloat -> (Int, Float) -> Float
ʰd̲ropDmgfunctionFloat -> Int -> Float
ʰa̲reafunctiona -> a
ʰh̲asAreafunction(Num a, Truthy b) => a -> b
ʰs̲etAreafunctionFloat -> (Int, Float) -> Float
ʰd̲ropAreafunctionFloat -> Int -> Float
ʰc̲hillfunctiona -> a
ʰh̲asChillfunction(Num a, Truthy b) => a -> b
ʰs̲etChillfunctionFloat -> (Int, Float) -> Float
ʰd̲ropChillfunctionFloat -> Int -> Float
ʰt̲owerfunctiona -> a
ʰh̲asTowerfunction(Num a, Truthy b) => a -> b
ʰs̲etTowerfunctionFloat -> (Int, Float) -> Float
ʰd̲ropTowerfunctionFloat -> Int -> Float
ʰc̲reepfunctiona -> a
ʰh̲asCreepfunction(Num a, Truthy b) => a -> b
ʰs̲etCreepfunctionFloat -> (Int, Float) -> Float
ʰd̲ropCreepfunctionFloat -> Int -> Float
ʰs̲hotfunctiona -> a
ʰh̲asShotfunction(Num a, Truthy b) => a -> b
ʰs̲etShotfunctionFloat -> (Int, Float) -> Float
ʰd̲ropShotfunctionFloat -> Int -> Float
rowsvalueBox Char
cellsvalueChar
RvalueInt
CvalueInt
GRASSvalueInt
ROADvalueInt
FARvalueInt
ʰs̲hiftfunctionInt -> Int -> Int
COLvalueInt
ʰf̲loodfunctionInt -> Int
DISTvalueInt
PATHvalueInt
PXvalueFloat
PYvalueFloat
LONGvalueInt
ʰc̲olfunctionBox Char -> Int -> Float
TTvalueBox Char
RANGEvalueFloat
DAMAGEvalueFloat
COOLDOWNvalueFloat
SPLASHvalueFloat
CHILLvalueFloat
COSTvalueInt
CTvalueBox Char
HPvalueFloat
SPEEDvalueFloat
ARMORvalueFloat
BOUNTYvalueInt
LEAKvalueInt
LETTERSvalueChar
WAVESvalueBox Char
startvalueInt
ARTvalueBool
PIECESvalueBox Char
SHOTvalueFloat
GAPvalueFloat
ʰp̲airfunction(a, a) -> a
ʰr̲owsfunction(a, Int) -> a
ʰc̲olsfunction(a, Int) -> a
ˡn̲ewfunction(Any a, Num b, Num c, Num d, Num e, Num f, Num g, Num h) => a -> (Float, Int, Int, b, c, Float, d, e, f, Float, g, h, Char)
ʰc̲reepsfunctionNum a => a -> Int
ʰt̲owersfunctionNum a => a -> Int
ʰs̲hotsfunctionNum a => a -> Int
ʰa̲longfunctionFloat -> Float
ʰs̲pawningfunction(Float, Int, Float) -> (Float, Int, Float)
ʰc̲rawlfunctionFloat -> Float -> (Float, Int)
ʰr̲owfunctionNum a => a -> Int -> Int
ʰa̲imfunctionFloat -> Float -> Float
ʰi̲mpactfunctionFloat -> Int -> Float
ʰf̲lyfunctionFloat -> Float -> Float
ʰb̲eatenfunctionFloat -> (Float, Int)
ʰo̲utcomefunction(Num a, Num c, Num d) => (a, Int, b, c) -> d
ˡt̲ickfunction(Any a, Num b, Any c, Num d, Num e, Any f) => (Float, Int, Int, Int, Int, Float, a, b, c, Float, d, e, f) -> Float -> (Float, Int, Int, Int, Int, Float, a, b, c, Float, d, e, f)
ʰw̲avefunction(Any a, Num b, Any c, Num d, Num e) => (Float, Int, a, Int, Int, Float, Int, b, Int, c, d, e, Char) -> (Float, Int, a, Int, Int, Float, Int, b, Int, c, d, e, Char)
ʰt̲owerAtfunctionFloat -> Float -> Int
ʰb̲oxZfunctionFloat -> Float
ʰo̲nfunctionFloat -> Int -> Int
ʰb̲uildfunction(Any a, Num b, Any c, Num d, Num e) => (Float, Int, a, Int, Int, Float, Int, b, Int, c, d, e, Char) -> Int -> (Float, Int, a, Int, Int, Float, Int, b, Int, c, d, e, Char)
ʰu̲pgradefunction(Any a, Num b, Any c, Num d, Num e) => ((Float, Int, a, Int, Int, Float, Int, b, Int, c, d, e, Char), Int) -> (Float, Int, a, Int, Int, Float, Int, b, Int, c, d, e, Char)
PAGESvalueInt
ʰs̲aidfunction(Any a, Num b, Any c, Num d, Num e) => ((Float, Int, a, Int, Int, Float, Int, b, Int, c, d, e, Char), Char) -> (Float, Int, a, Int, Int, Float, Int, b, Int, c, d, e, Char)
ʰf̲asterfunction(Any a, Num b, Any c, Num d, Num e) => (Float, Int, a, Int, Int, Float, Int, b, Int, c, d, e, Char) -> (Float, Int, a, Int, Int, Float, Int, b, Int, c, d, e, Char)
ʰs̲etfunction(Any a, Num b, Any c, Num d, Num e) => (Float, Int, a, Int, Int, Float, Int, b, Int, c, d, e, Char) -> (Int, b, Int) -> (Float, Int, a, Int, Int, Float, Int, b, Int, c, d, e, Char)
TWvalueFloat
THvalueFloat
OXvalueFloat
OYvalueFloat
VIEWvalueFloat
BARvalueFloat
BOOKvalueFloat
ʰt̲ilefunctionFloat -> Int
ˡc̲lickfunction(Any a, Num b, Any c, Num d, Num e) => (Float, Int, a, Int, Int, Float, Int, b, Int, c, d, e, Char) -> Float -> (Float, Int, a, Int, Int, Float, Int, b, Int, c, d, e, Char)
PANELvalueFloat
ʰb̲ookHitfunctionFloat -> Int
ʰb̲ookfunction(Any a, Num b, Any c, Num d, Num e) => ((Float, Int, a, Int, Int, Float, Int, b, Int, c, d, e, Char), Int) -> (Float, Int, a, Int, Int, Float, Int, b, Int, c, d, e, Char)
ˡk̲eyfunction(Any a, Num b, Any c, Num d, Num e) => (Float, Int, a, Int, Int, Float, Int, b, Int, c, d, e, Char) -> Char -> (Float, Int, a, Int, Int, Float, Int, b, Int, c, d, e, Char)
ˡs̲tatusfunction(Any a, Any b, Any c, Any d, Any e, Any f, Any g, Any h, Any i, Any j, Any k, Any l, Any m) => (a, b, c, d, e, f, g, h, i, j, k, l, m) -> k
ˡs̲corefunction(Any a, Any c, Any d, Any e, Any f, Any g, Any h, Any i, Any j, Any k) => (a, b, b, b, c, d, e, f, g, h, i, j, k) -> b
ˡc̲ountsfunction(Num a, Any b, Any c, Any d, Any e, Any f, Any g, Any h, Any i, Any j, Any k, Any l, Any m) => (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Int
ˡt̲owersfunction(Any a, Any b, Any c, Any d, Any e, Any f, Any g, Any h, Any i, Any j, Any k, Any l) => (Float, a, b, c, d, e, f, g, h, i, j, k, l) -> Float
ˡr̲oadfunctionAny a => a -> Int
ʰs̲xfunction(Float, Float) -> Float
ʰs̲yfunction(Float, Float, Float) -> Float
ʰp̲olyfunction(Float, Float, Float, Char) -> Char
ʰt̲ileAtfunctionInt -> Box Char
BOARDvalueChar
FACESvalueBox Char
ʰb̲oxfunction(Float, Float, Float, Float, Float, Int) -> Char
ʰd̲rawTowerfunction(Float, Float, Int, Int, Float) -> Char
TOWERARTvalueBox Char
ʰp̲lacedfunction(Float, Float, Int) -> Char
ʰu̲pLabelfunction(Float, Float, Int, Int) -> Char
ʰl̲abelZfunctionInt -> Float
ʰu̲pWordsfunctionTruthy a => (a, Int) -> Char
SPRITEvalueFloat
ʰs̲pritefunction(Float, Float, a) -> Char
ʰh̲pBarfunction(Float, Float, Int, Float, Float) -> Char
CREEPCOLORSvalueBox Char
ʰd̲rawCreepfunction(Float, Float, Int, Float) -> Char
ʰs̲hotAtfunction(Float, Float) -> Char
ʰt̲hingsfunction(Float, Int) -> Box Char
ʰt̲hingsIffunctionNum a => (Float, Int, a) -> Box Char
ʰt̲hingfunction(Float, Int, Float, Int) -> Char
ʰb̲uttonfunction(Float, a, Int) -> Box Char
ʰb̲arfunctionInt -> Char
BARSvalueBox Char
ʰw̲rapfunctionChar -> Int -> Box Char
ʰl̲enfunctionBox Char -> Int
ʰp̲anelfunctionTruthy a => a -> Char
ʰp̲agefunction(Int, Float) -> Box Char
ʰs̲pinfunction(Int, Float) -> Box Char
ʰa̲boutfunctionInt -> Box Char
ʰn̲extUpfunctionInt -> Char
ʰc̲reepAboutfunctionInt -> Box Char
ʰw̲ordsfunction(Float, Float, Float) -> Char -> Box Char
ʰs̲aysfunction(Num d, Num e) => (a, b, c, d, e) -> Char
ˡd̲rawfunction(Any c, Any d, Num e, Num f, Num g) => (Float, Int, a, b, c, d, Int, e, Int, Float, f, g, Char) -> Char
ʰb̲ookIffunctionNum a => (a, Int, Float) -> Box Char
SCALEvalueFloat
ʰj̲sonfunctionFloat -> Char
ʰq̲uotefunctionChar -> Char
MIDvalueFloat
MIDZvalueFloat
ʰc̲amerafunction(Float, Float) -> Char
ʰp̲iecefunction(Char, Float, Float, Float, Float, Char, Float) -> Char
ʰt̲owerPiecesfunction(Float, Float) -> Box Char
ʰt̲owerPiecefunction(Float, Int, Float) -> Char
ʰc̲reepPiecesfunction(Float, Float) -> Box Char
ʰc̲reepPiecefunction(Float, Int, Float) -> Char
ROADTEXTvalueChar
ʰb̲oardScenefunction(Float, Float) -> Char
ʰb̲ookScenefunction(Int, Float) -> Char
ʰz̲oomfunctionInt -> Float
ʰh̲eightfunctionInt -> Float
ʰs̲ceneIffunctionNum a => (Float, a, Int, Float) -> Box Char
ᵘs̲howfunction(Num a, Num b, Num c) => (Float, Int, Int, Int, Int, Float, Int, a, Int, Float, b, c, Char) -> Char
ᵘl̲oopfunction(Num a, Num b, Num c) => (Float, Int, Int, Int, Int, Float, Int, a, Int, Float, b, c, Char) -> Char
ᵘq̲uitfunction(Num a, Num b, Num c) => (Float, Int, Int, Int, Int, Float, Int, a, Int, Float, b, c, Char) -> Char
ᵘe̲ndfunction(Num a, Num b, Num c) => (Float, Int, Int, Int, Int, Float, Int, a, Int, Float, b, c, Char) -> Char
startvalue(Float, Int, Int, Int, Int, Float, Int, Int, Int, Float, Int, Int, Char)
arrowsvalue(Float, Int, Int, Int, Int, Float, Int, Int, Int, Float, Int, Int, Char)
builtvalue(Float, Int, Int, Int, Int, Float, Int, Int, Int, Float, Int, Int, Char)
wavevalue(Float, Int, Int, Int, Int, Float, Int, Int, Int, Float, Int, Int, Char)
ᵘg̲ofunction(Any a, Num b, Any c, Num d, Num e, Any f, Num g) => (Float, Int, Int, Int, Int, Float, a, b, c, Float, d, e, f) -> g -> (Float, Int, Int, Int, Int, Float, a, b, c, Float, d, e, f)
latervalue(Float, Int, Int, Int, Int, Float, Int, Int, Int, Float, Int, Int, Char)
_functionChar
_functionUnit
_functionUnit
startvalue(Float, Int, Int, Int, Float, Int, Float)
WvalueFloat
ᵘf̲irefunction(Num a, Num b, Num c) => (Float, Int, a, Int, Float, b, Float) -> c -> (Float, Int, a, Int, Float, b, Float)
firedvalue(Float, Int, Int, Int, Float, Int, Float)
latervalue(Float, Int, Int, Int, Float, Int, Float)
_functionChar
_functionUnit
_functionUnit
_functionUnit
ʰw̲orldfunctionInt -> Float
ʰp̲osfunctiona -> a
ʰh̲asPosfunction(Num a, Truthy b) => a -> b
ʰs̲etPosfunctionFloat -> (Int, Float) -> Float
ʰd̲ropPosfunctionFloat -> Int -> Float
ʰv̲elfunctiona -> a
ʰh̲asVelfunction(Num a, Truthy b) => a -> b
ʰs̲etVelfunctionFloat -> (Int, Float) -> Float
ʰd̲ropVelfunctionFloat -> Int -> Float
ʰd̲irfunctiona -> a
ʰh̲asDirfunction(Num a, Truthy b) => a -> b
ʰs̲etDirfunctionFloat -> (Int, Float) -> Float
ʰd̲ropDirfunctionFloat -> Int -> Float
ʰs̲izefunctiona -> a
ʰh̲asSizefunction(Num a, Truthy b) => a -> b
ʰs̲etSizefunctionFloat -> (Int, Float) -> Float
ʰd̲ropSizefunctionFloat -> Int -> Float
ʰl̲ifefunctiona -> a
ʰh̲asLifefunction(Num a, Truthy b) => a -> b
ʰs̲etLifefunctionFloat -> (Int, Float) -> Float
ʰd̲ropLifefunctionFloat -> Int -> Float
ʰs̲hipfunctiona -> a
ʰh̲asShipfunction(Num a, Truthy b) => a -> b
ʰs̲etShipfunctionFloat -> (Int, Float) -> Float
ʰd̲ropShipfunctionFloat -> Int -> Float
ʰr̲ockfunctiona -> a
ʰh̲asRockfunction(Num a, Truthy b) => a -> b
ʰs̲etRockfunctionFloat -> (Int, Float) -> Float
ʰd̲ropRockfunctionFloat -> Int -> Float
ʰs̲hotfunctiona -> a
ʰh̲asShotfunction(Num a, Truthy b) => a -> b
ʰs̲etShotfunctionFloat -> (Int, Float) -> Float
ʰd̲ropShotfunctionFloat -> Int -> Float
ʰn̲umsfunctionChar -> Float
FIELDvalueFloat
FXvalueFloat
FYvalueFloat
WAVESvalueInt
RADIIvalueFloat
SPEEDSvalueFloat
POINTSvalueInt
shipvalueFloat
TURNvalueFloat
THRUSTvalueFloat
FASTvalueFloat
DRAGvalueFloat
LIVESvalueInt
SAFEvalueFloat
gunvalueFloat
SHOTvalueFloat
FLIGHTvalueFloat
SHOTSvalueFloat
ʰp̲airfunction(a, a) -> a
ʰr̲adiansfunctionNum a => a -> Float
ʰp̲lacefunctionFloat -> (Int, Float, Float) -> Float
ʰw̲avefunctionFloat -> Int -> Float
ʰc̲enterfunctionFloat -> Int -> Float
ˡn̲ewfunction(Any a, Num b, Num c, Num d) => a -> (Float, b, Int, c, Float, d, Float)
ʰm̲efunctionNum a => a -> Int
ʰr̲ocksfunctionNum a => a -> Int
ʰs̲hotsfunctionNum a => a -> Int
ʰm̲ovefunctionFloat -> Float -> Float
ʰa̲gefunctionFloat -> Float -> Float
ʰw̲ithinfunctionTruthy a => Float -> (Float, Int, Float) -> a
ʰh̲alvesfunctionFloat -> (Int, Int) -> Float
ʰs̲hootfunctionFloat -> (Float, Int)
ʰc̲rashfunctionNum a => (Float, a, Float) -> (Float, a, Float)
ʰn̲extfunctionNum a => (Float, Int) -> (Float, Int, a)
ʰs̲tandingfunction(Num a, Num b, Num c) => (a, b) -> c
ˡt̲ickfunction(Num a, Num b) => (Float, Int, a, Int, Float, b, Float) -> Float -> (Float, Int, a, Int, Float, b, Float)
ʰf̲irefunctionFloat -> Int -> Float
ʰt̲hrustfunctionFloat -> Int -> Float
ˡk̲eyfunction(Any a, Any b, Any c, Any d, Num e, Any f) => (Float, a, b, c, d, e, f) -> Char -> (Float, a, b, c, d, e, f)
ˡs̲tatusfunction(Any a, Any b, Any c, Any d, Any e, Any f, Any g) => (a, b, c, d, e, f, g) -> f
ˡs̲corefunction(Any a, Any c, Any d, Any e) => (a, b, b, b, c, d, e) -> b
ˡc̲ountsfunction(Num a, Any b, Any c, Any d, Any e, Any f, Any g) => (a, b, c, d, e, f, g) -> Int
ˡs̲hipfunction(Num a, Any b, Any c, Any d, Any e, Any f, Any g) => (a, b, c, d, e, f, g) -> a
ˡr̲ocksfunction(Num a, Any b, Any c, Any d, Any e, Any f, Any g) => (a, b, c, d, e, f, g) -> a
ʰu̲nitsfunctionFloat -> Char
ʰd̲rawRockfunction(Float, Float, Float) -> Box Char
ʰd̲rawShotfunction(Float, Float) -> Box Char
ʰd̲rawShipfunction(Float, Float, Float, Float) -> Box Char
ʰs̲aysfunction(Num d, Num e) => (a, b, c, d, e) -> Char
ˡd̲rawfunction(Num d, Num e) => (Float, a, b, c, d, e, Float) -> Char
ᵘs̲howfunctionNum a => (Float, Int, Int, Int, Float, a, Float) -> Char
ᵘl̲oopfunctionNum a => (Float, Int, Int, Int, Float, a, Float) -> Char
ᵘq̲uitfunctionNum a => (Float, Int, Int, Int, Float, a, Float) -> Char
ᵘe̲ndfunctionNum a => (Float, Int, Int, Int, Float, a, Float) -> Char
ᵘs̲howfunctionNum a => (Float, Float, Float, Float, a) -> Char
ᵘl̲oopfunctionNum a => (Float, Float, Float, Float, a) -> Char
ᵘe̲ndfunctionNum a => (Float, Float, Float, Float, a) -> Char
rowsvalueBox Char
cellsvalueChar
RvalueInt
CvalueInt
GRIDvalueInt
COLORSvalueFloat
movesvalueFloat
STEPvalueFloat
TURNvalueFloat
WIDEvalueFloat
RAYSvalueInt
ATvalueInt
ˡn̲ewfunction(Any a, Num b) => a -> (Float, Float, Float, Float, b)
ʰt̲ilefunction(Num a, Num b) => (a, b) -> Int
ʰf̲itsfunctionTruthy a => (Float, Float) -> a
ʰd̲oorfunctionTruthy a => (Float, Float) -> a
ʰm̲ovedfunction(Any a, Any b, Num c) => (Float, Float, a, b, c, Float, Float) -> (Float, Float, a, b, c)
ˡk̲eyfunction(Any a, Num b) => (Float, Float, Float, a, b) -> Char -> (Float, Float, Float, a, b)
ˡt̲ickfunction(Any a, Any b, Any c, Num d, Num e) => (a, b, c, d, e) -> d -> (a, b, c, d, e)
ʰr̲aysfunctionNum a => a -> (Float, Float)
ʰs̲tepfunction(Num a, Truthy a, Truthy b, Num c) => (a, a, Float, Float, Float, Float, a, a, a, b, c) -> (a, a, Float, Float, Float, Float, a, a, a, b, c)
ʰc̲astfunctionNum a => (Float, Float, a) -> (Int, Int, Float)
ˡs̲tatusfunction(Any a, Any b, Any c, Any d, Any e) => (a, b, c, d, e) -> e
ˡy̲oufunctionAny b => (a, a, a, a, b) -> a
ˡs̲eesfunction(Num a, Any b, Any c) => (Float, Float, a, b, c) -> Float
VIEWvalueFloat
TOPvalueFloat
HIGHvalueFloat
ʰc̲olumnfunction(Num a, Num b) => (a, Int, b, Float) -> Box Char
MAPXvalueFloat
MAPYvalueFloat
ʰm̲apTilefunctionInt -> Box Char
ʰm̲apFillfunctionInt -> Char
MAPvalueChar
ʰy̲ouOnMapfunctionNum a => (Float, Float, a) -> Box Char
ʰw̲ordsfunction(Float, Float, Float) -> a -> Box Char
ʰs̲aysfunction(Num a, Num b) => (a, b) -> Char
ˡd̲rawfunction(Num a, Num b, Num c) => (Float, Float, a, b, c) -> Char
svalue(Float, Float, Float, Float, Int)
rvalueFloat
ᵘp̲ressfunction(Any a, Num b) => (Float, Float, Float, a, b) -> Char -> (Float, Float, Float, a, b)
ᵘk̲eysfunction(Any a, Num b) => (Float, Float, Float, a, b) -> Box Char -> (Float, Float, Float, a, b)
turnedvalue(Float, Float, Float, Float, Int)
_functionChar
_functionUnit
_functionUnit
_functionUnit