Skip to content

Instantly share code, notes, and snippets.

@strager

strager/hello-world.ktn.ssa

Last active December 24, 2015 20:29
Show Gist options

  • Select an option

    Learn more about clone URLs
  • Save strager/6857977 to your computer and use it in GitHub Desktop.

Select an option

Learn more about clone URLs
Save strager/6857977 to your computer and use it in GitHub Desktop.
Download ZIP
Hello World in Kitten SSA form
Raw
hello-world.ktn.ssa
// NOTE: apply is broken!
// NOTE: arity is incorrect.
// NOTE: parameters are not yet explicit.
!= (0 -> 0):
s0 <- neInt p0 p1
return s0
!=. (0 -> 0):
s0 <- neFloat p0 p1
return s0
# (0 -> 0):
s0 <- get p0 p1
return s0
#! (0 -> 0):
s0 <- call global # p0 p1
s1 <- call global fromSome s0
return s1
## (0 -> 0):
s0 <- call global # p1 p2
s1 <- call global id s0
s2 <- act c0
s3 <- act c1
s4 <- optionElse s3 s2 s1
return s4
c0 (0 -> 0):
s0 <- call global # p0 p1
return s0
c1 (0 -> 0):
s0 <- call global none
return s0
##! (0 -> 0):
s0 <- call global #! p1 p2
s1 <- call global #! p0 s0
return s1
##= (0 -> 0):
s0 <- act c0
s1 <- call global #@ p1 s0 p3
return s1
c0 (0 -> 0):
s0 <- call global #= p0 p1 p2
return s0
#= (0 -> 0):
s0 <- set p0 p1 p2
return s0
#@ (0 -> 0):
s0 <- call global # p0 p2
s1 <- act c0
s2 <- act c1
s3 <- optionElse s2 s1 s0
return s3
c0 (0 -> 0):
<- apply p0
s0 <- call global #= p1 p2 p3
return s0
c1 (0 -> 0):
return
% (0 -> 0):
s0 <- modInt p0 p1
return s0
%. (0 -> 0):
s0 <- modFloat p0 p1
return s0
& (0 -> 0):
s0 <- andInt p0 p1
return s0
&& (0 -> 0):
s0 <- andBool p0 p1
return s0
* (0 -> 0):
s0 <- mulInt p0 p1
return s0
*. (0 -> 0):
s0 <- mulFloat p0 p1
return s0
+ (0 -> 0):
s0 <- addInt p0 p1
return s0
++ (0 -> 0):
s0 <- int 1
s1 <- call global + s0 p0
return s1
++. (0 -> 0):
s0 <- float 1.0
s1 <- call global +. s0 p0
return s1
+. (0 -> 0):
s0 <- addFloat p0 p1
return s0
- (0 -> 0):
s0 <- subInt p0 p1
return s0
-- (0 -> 0):
s0 <- int 1
s1 <- call global - s0 p0
return s1
--. (0 -> 0):
s0 <- float 1.0
s1 <- call global -. s0 p0
return s1
-. (0 -> 0):
s0 <- subFloat p0 p1
return s0
.. (0 -> 0):
s0 <- call global rangeTo p0 p1
return s0
... (0 -> 0):
s0 <- call global rangeUntil p0 p1
return s0
/ (0 -> 0):
s0 <- divInt p0 p1
return s0
/. (0 -> 0):
s0 <- divFloat p0 p1
return s0
< (0 -> 0):
s0 <- ltInt p0 p1
return s0
<. (0 -> 0):
s0 <- ltFloat p0 p1
return s0
<= (0 -> 0):
s0 <- leInt p0 p1
return s0
<=. (0 -> 0):
s0 <- leFloat p0 p1
return s0
<> (0 -> 0):
s0 s1 <- call global dup p0
return s0 s1
= (0 -> 0):
s0 <- eqInt p0 p1
return s0
=. (0 -> 0):
s0 <- eqFloat p0 p1
return s0
> (0 -> 0):
s0 <- gtInt p0 p1
return s0
>. (0 -> 0):
s0 <- gtFloat p0 p1
return s0
>< (0 -> 0):
s0 s1 <- call global swap p0 p1
return s0 s1
>= (0 -> 0):
s0 <- geInt p0 p1
return s0
>=. (0 -> 0):
s0 <- geFloat p0 p1
return s0
^ (0 -> 0):
s0 <- xorInt p0 p1
return s0
^^ (0 -> 0):
s0 <- xorBool p0 p1
return s0
absFloat (0 -> 0):
s0 s1 <- call global dup p0
s2 <- float 0.0
s3 <- call global <. s2 s1
s4 <- act c0
s5 <- if s4 s3
return s0 s5
c0 (0 -> 0):
s0 <- call global negFloat p0
return s0
absInt (0 -> 0):
s0 s1 <- call global dup p0
s2 <- int 0
s3 <- call global < s2 s1
s4 <- act c0
s5 <- if s4 s3
return s0 s5
c0 (0 -> 0):
s0 <- call global negInt p0
return s0
all (0 -> 0):
s0 <- call global map p0 p1
s1 <- call global and s0
return s1
and (0 -> 0):
s0 <- bool true
s1 <- act c0
s2 <- call global foldl s1 s0 p0
return s2
c0 (0 -> 0):
s0 <- call global && p0 p1
return s0
any (0 -> 0):
s0 <- call global map p0 p1
s1 <- call global or s0
return s1
append (0 -> 0):
s0 <- call global vector p0
s1 <- call global cat s0 p1
return s1
both (0 -> 0):
<- apply p1
<- apply p0
return p3 p2
bothTo (0 -> 0):
<- apply p1
<- apply p0
return p2 p2
cartesian (0 -> 0):
s0 <- act c0
s1 <- call global cartesianWith s0 p0 p1
return s1
c0 (0 -> 0):
s0 <- call global pair p0 p1
return s0
cartesianWith (0 -> 0):
s0 <- act c0
s1 <- call global mapConcat s0 p2
return s1
c0 (0 -> 0):
s0 <- act c0
s1 <- call global map s0 p1
return s1
c0 (0 -> 0):
<- apply p0
return
cat (0 -> 0):
s0 <- addVector p0 p1
return s0
charToInt (0 -> 0):
s0 <- charToInt p0
return s0
compose (0 -> 0):
s0 <- act c0
return s0
c0 (0 -> 0):
<- apply p0
<- apply p1
return
concat (0 -> 0):
s0 <- vector
s1 <- act c0
s2 <- call global foldl s1 s0 p0
return s2
c0 (0 -> 0):
s0 <- call global cat p0 p1
return s0
cond (0 -> 0):
s0 <- call global head p1
s1 <- act c0
s2 <- act c1
s3 <- optionElse s2 s1 s0
return s3
c0 (0 -> 0):
s0 <- call global first p0
<- apply s0
s1 <- act c0
s2 <- act c1
s3 <- optionElse s2 s1 p1
return s3
c0 (0 -> 0):
s0 <- call global rest p0
<- apply s0
return
c1 (0 -> 0):
s0 <- call global tail p0
s1 <- call global cond s0 p1 p2
return s1
c1 (0 -> 0):
<- apply p0
return
cond1 (0 -> 0):
s0 <- call global head p0
s1 <- call global fromSome s0
s2 <- call global first s1
<- apply s2
s3 <- act c0
s4 <- act c1
s5 <- optionElse s4 s3 p1
return s5
c0 (0 -> 0):
s0 <- call global rest p0
<- apply s0
return
c1 (0 -> 0):
s0 <- call global tail p0
s1 <- call global cond1 s0 p1
return s1
const (0 -> 0):
s0 <- act c0
return s0
c0 (0 -> 0):
<- call global drop p0
return
drop (0 -> 0):
return
dup (0 -> 0):
return p0 p0
each (0 -> 0):
s0 <- call global head p1
s1 <- act c0
s2 <- option s1 s0
return s2
c0 (0 -> 0):
<- apply p0
s0 <- call global tail p1
<- call global each s0 p2
return
elem (0 -> 0):
s0 <- act c0
s1 <- call global any s0 p2
return s1
c0 (0 -> 0):
<- apply p0
return
elemChar (0 -> 0):
s0 <- act c0
s1 <- call global elem s0 p0 p1
return s1
c0 (0 -> 0):
s0 <- call global eqChar p0 p1
return s0
elemInt (0 -> 0):
s0 <- act c0
s1 <- call global elem s0 p0 p1
return s1
c0 (0 -> 0):
s0 <- call global = p0 p1
return s0
eqChar (0 -> 0):
s0 <- act c0
s1 s2 <- call global toBoth s0 p0 p1
s3 <- call global = s2 s1
return s3
c0 (0 -> 0):
s0 <- call global charToInt p0
return s0
eqString (0 -> 0):
s0 <- act c0
s1 <- call global eqVector s0 p0 p1
return s1
c0 (0 -> 0):
s0 <- call global eqChar p0 p1
return s0
eqUnit (0 -> 0):
<- call global drop p0
<- call global drop p1
s0 <- bool true
return s0
eqVector (0 -> 0):
s0 <- call global length p2
s1 <- call global length p1
s2 <- call global != s1 s0
s3 <- act c0
s4 <- act c1
s5 <- ifElse s4 s3 s2
return s5
c0 (0 -> 0):
s0 <- bool false
return s0
c1 (0 -> 0):
s0 <- call global zipWith p0 p1 p2
s1 <- call global and s0
return s1
evenFloat (0 -> 0):
s0 <- float 2.0
s1 <- call global %. s0 p0
s2 <- float 0.0
s3 <- call global =. s2 s1
return s3
evenInt (0 -> 0):
s0 <- int 2
s1 <- call global % s0 p0
s2 <- int 0
s3 <- call global = s2 s1
return s3
exit (0 -> 0):
p0 <- exit
return
filter (0 -> 0):
s0 <- call global head p1
s1 <- act c0
s2 <- act c1
s3 <- optionElse s2 s1 s0
return s3
c0 (0 -> 0):
<- apply p0
s0 <- act c0
s1 <- act c1
s2 <- ifElse s1 s0 p1
return s2
c0 (0 -> 0):
s0 <- call global tail p0
s1 <- call global filter s0 p1
s2 <- call global prepend s1 p2
return s2
c1 (0 -> 0):
s0 <- call global tail p0
s1 <- call global filter s0 p1
return s1
c1 (0 -> 0):
s0 <- vector
return s0
find (0 -> 0):
s0 <- call global filter p0 p1
s1 <- call global head s0
return s1
first (0 -> 0):
s0 <- first p0
return s0
flip (0 -> 0):
s0 <- call global rest p0
s1 <- call global first p0
s2 <- pair s0 s1
return s2
foldl (0 -> 0):
s0 <- call global head p2
s1 <- act c0
s2 <- act c1
s3 <- optionElse s2 s1 s0
return s3
c0 (0 -> 0):
s0 <- call global tail p1
<- apply p0
s1 <- call global foldl s0 p2 p3
return s1
c1 (0 -> 0):
return
foldl1 (0 -> 0):
s0 <- call global tail p1
s1 <- call global unsafeHead p1
s2 <- call global foldl p0 s1 s0
return s2
foldr (0 -> 0):
s0 <- call global head p2
s1 <- act c0
s2 <- act c1
s3 <- optionElse s2 s1 s0
return s3
c0 (0 -> 0):
s0 <- call global tail p0
s1 <- call global foldr s0 p1 p2
<- apply s1
return
c1 (0 -> 0):
return
foldr1 (0 -> 0):
s0 <- call global init p1
s1 <- call global unsafeLast p1
s2 <- call global foldr p0 s1 s0
return s2
fourth (0 -> 0):
s0 <- call global rest p0
s1 <- call global rest s0
s2 <- call global rest s1
s3 <- call global first s2
return s3
fromLeft (0 -> 0):
s0 <- fromLeft p0
return s0
fromOption (0 -> 0):
s0 <- act c0
s1 <- act c1
s2 <- optionElse s1 s0 p1
return s2
c0 (0 -> 0):
s0 <- call global id p0
return s0
c1 (0 -> 0):
return
fromRight (0 -> 0):
s0 <- fromRight p0
return s0
fromSome (0 -> 0):
s0 <- fromSome p0
return s0
function (0 -> 0):
s0 <- act c0
return s0
c0 (0 -> 0):
return
geChar (0 -> 0):
s0 <- act c0
s1 s2 <- call global toBoth s0 p0 p1
s3 <- call global >= s2 s1
return s3
c0 (0 -> 0):
s0 <- call global charToInt p0
return s0
getAll (0 -> 0):
s0 <- act c0
s1 <- call global map s0 p0
return s1
c0 (0 -> 0):
s0 s1 <- call global swap p0 p1
s2 <- call global # s1 s0
return s2
getLeft (0 -> 0):
s0 <- call global id p0
s1 <- act c0
s2 <- act c1
s3 <- choiceElse s2 s1 s0
return s3
c0 (0 -> 0):
s0 <- call global some p0
return s0
c1 (0 -> 0):
<- call global drop p0
s0 <- call global none
return s0
getLine (0 -> 0):
s0 <- call global stdin
s1 <- getLine s0
return s1
getRight (0 -> 0):
s0 <- call global id p0
s1 <- act c0
s2 <- act c1
s3 <- choiceElse s2 s1 s0
return s3
c0 (0 -> 0):
<- call global drop p0
s0 <- call global none
return s0
c1 (0 -> 0):
s0 <- call global some p0
return s0
gtChar (0 -> 0):
s0 <- act c0
s1 s2 <- call global toBoth s0 p0 p1
s3 <- call global > s2 s1
return s3
c0 (0 -> 0):
s0 <- call global charToInt p0
return s0
handleClose (0 -> 0):
p0 <- close
return
handleGetLine (0 -> 0):
s0 <- getLine p0
return s0
handlePrint (0 -> 0):
s0 <- print p0
return s0
head (0 -> 0):
s0 <- int 0
s1 <- call global # s0 p0
return s1
headTail (0 -> 0):
s0 <- call global head p0
s1 <- call global tail p0
return s0 s1
id (0 -> 0):
return p0
init (0 -> 0):
s0 <- init p0
return s0
insert (0 -> 0):
s0 <- call global head p2
s1 <- act c0
s2 <- act c1
s3 <- optionElse s2 s1 s0
return s3
c0 (0 -> 0):
<- apply p0
s0 <- act c0
s1 <- act c1
s2 <- ifElse s1 s0 p1
return s2
c0 (0 -> 0):
s0 <- call global tail p0
s1 <- call global insert s0 p1 p2
s2 <- call global prepend s1 p3
return s2
c1 (0 -> 0):
s0 <- call global prepend p0 p1
return s0
c1 (0 -> 0):
s0 <- vector p0
return s0
insertEverywhere (0 -> 0):
s0 <- call global head p1
s1 <- act c0
s2 <- act c1
s3 <- optionElse s2 s1 s0
return s3
c0 (0 -> 0):
s0 <- call global tail p1
s1 <- call global insertEverywhere s0 p2
s2 <- act c0
s3 <- call global map s2 s1
s4 <- call global prepend s3 p3
s5 <- call global prepend s4 p4
return s5
c0 (0 -> 0):
s0 <- call global prepend p0 p1
return s0
c1 (0 -> 0):
s0 <- vector p0
s1 <- vector s0
return s1
intToChar (0 -> 0):
s0 <- intToChar p0
return s0
intersperse (0 -> 0):
s0 <- call global head p1
s1 <- act c0
s2 <- act c1
s3 <- optionElse s2 s1 s0
return s3
c0 (0 -> 0):
s0 <- call global tail p1
s1 <- call global prependToAll s0 p2
s2 <- call global prepend p0 s1
return s2
c1 (0 -> 0):
s0 <- vector
return s0
isEmpty (0 -> 0):
s0 <- call global length p0
s1 <- int 0
s2 <- call global = s1 s0
return s2
isLeft (0 -> 0):
s0 <- call global id p0
s1 <- act c0
s2 <- act c1
s3 <- choiceElse s2 s1 s0
return s3
c0 (0 -> 0):
<- call global drop p0
s0 <- bool true
return s0
c1 (0 -> 0):
<- call global drop p0
s0 <- bool false
return s0
isNone (0 -> 0):
s0 <- call global id p0
s1 <- act c0
s2 <- act c1
s3 <- optionElse s2 s1 s0
return s3
c0 (0 -> 0):
<- call global drop p0
s0 <- bool false
return s0
c1 (0 -> 0):
s0 <- bool true
return s0
isRight (0 -> 0):
s0 <- call global id p0
s1 <- act c0
s2 <- act c1
s3 <- choiceElse s2 s1 s0
return s3
c0 (0 -> 0):
<- call global drop p0
s0 <- bool false
return s0
c1 (0 -> 0):
<- call global drop p0
s0 <- bool true
return s0
isSome (0 -> 0):
s0 <- call global id p0
s1 <- act c0
s2 <- act c1
s3 <- optionElse s2 s1 s0
return s3
c0 (0 -> 0):
<- call global drop p0
s0 <- bool true
return s0
c1 (0 -> 0):
s0 <- bool false
return s0
join (0 -> 0):
s0 <- call global intersperse p0 p1
s1 <- call global concat s0
return s1
keep (0 -> 0):
s0 <- int 0
s1 <- call global <= s0 p0
s2 <- act c0
s3 <- act c1
s4 <- ifElse s3 s2 s1
return s4
c0 (0 -> 0):
s0 <- vector
return s0
c1 (0 -> 0):
s0 <- call global head p0
s1 <- act c0
s2 <- act c1
s3 <- optionElse s2 s1 s0
return s3
c0 (0 -> 0):
s0 <- call global tail p1
s1 <- call global -- s0
s2 <- call global keep s1 p2
s3 <- call global prepend p0 s2
return s3
c1 (0 -> 0):
s0 <- vector
return s0
keepWhile (0 -> 0):
s0 <- vector
s1 <- call global head p1
s2 <- act c0
s3 <- option s2 s1
return s0 s3
c0 (0 -> 0):
<- apply p0
s0 <- act c0
s1 <- if s0 p1
return s1
c0 (0 -> 0):
<- call global drop p0
s0 <- call global tail p1
s1 <- call global keepWhile s0 p2
s2 <- call global prepend s1 p3
return s2
last (0 -> 0):
s0 s1 <- call global dup p0
s2 <- call global length s1
s3 <- int 1
s4 <- call global - s3 s2
s5 <- call global # s4 s0
return s5
leChar (0 -> 0):
s0 <- act c0
s1 s2 <- call global toBoth s0 p0 p1
s3 <- call global <= s2 s1
return s3
c0 (0 -> 0):
s0 <- call global charToInt p0
return s0
left (0 -> 0):
s0 <- makeLeft p0
return s0
length (0 -> 0):
s0 <- length p0
return s0
liftLeft (0 -> 0):
s0 <- call global id p1
s1 <- act c0
s2 <- act c1
s3 <- choiceElse s2 s1 s0
return s3
c0 (0 -> 0):
<- apply p0
s0 <- call global left p1
return s0
c1 (0 -> 0):
s0 <- call global right p0
return s0
liftOption (0 -> 0):
s0 <- call global id p1
s1 <- act c0
s2 <- act c1
s3 <- optionElse s2 s1 s0
return s3
c0 (0 -> 0):
<- apply p0
s0 <- call global some p1
return s0
c1 (0 -> 0):
s0 <- call global none
return s0
liftOption2 (0 -> 0):
s0 <- act c0
s1 <- act c1
s2 <- optionElse s1 s0 p2
return s2
c0 (0 -> 0):
s0 <- act c0
s1 <- act c1
s2 <- optionElse s1 s0 p1
return s2
c0 (0 -> 0):
<- apply p0
s0 <- call global some p1
return s0
c1 (0 -> 0):
s0 <- call global none
return s0
c1 (0 -> 0):
s0 <- call global none
return s0
liftRight (0 -> 0):
s0 <- call global id p1
s1 <- act c0
s2 <- act c1
s3 <- choiceElse s2 s1 s0
return s3
c0 (0 -> 0):
s0 <- call global left p0
return s0
c1 (0 -> 0):
<- apply p0
s0 <- call global right p1
return s0
loopWhile (0 -> 0):
<- apply p0
s0 <- act c0
s1 <- if s0 p1
return s1
c0 (0 -> 0):
<- call global loopWhile p0
return
ltChar (0 -> 0):
s0 <- act c0
s1 s2 <- call global toBoth s0 p0 p1
s3 <- call global < s2 s1
return s3
c0 (0 -> 0):
s0 <- call global charToInt p0
return s0
map (0 -> 0):
s0 <- call global head p1
s1 <- act c0
s2 <- act c1
s3 <- optionElse s2 s1 s0
return s3
c0 (0 -> 0):
<- apply p0
s0 <- call global vector p1
s1 <- call global tail s0
s2 <- call global map s1 p2
s3 <- call global cat s2 p3
return s3
c1 (0 -> 0):
s0 <- vector
return s0
mapConcat (0 -> 0):
s0 <- call global map p0 p1
s1 <- call global concat s0
return s1
mapFrom (0 -> 0):
s0 <- call global isEmpty p2
s1 <- call global length p2
s2 <- call global >= s1 p0
s3 <- call global || s2 s0
s4 <- act c0
s5 <- act c1
s6 <- ifElse s5 s4 s3
return s6
c0 (0 -> 0):
return
c1 (0 -> 0):
s0 <- call global #@ p0 p1 p2
s1 <- call global ++ s0
s2 <- call global mapFrom s1 p3 p4
return s2
mapRange (0 -> 0):
s0 <- call global <= p1 p2
s1 <- act c0
s2 <- act c1
s3 <- ifElse s2 s1 s0
return s3
c0 (0 -> 0):
<- apply p0
s0 <- call global ++ p1
s1 <- call global mapRange s0 p2 p3 p4
return s1
c1 (0 -> 0):
return
maxInt (0 -> 0):
s0 <- call global > p0 p1
s1 <- act c0
s2 <- act c1
s3 <- ifElse s2 s1 s0
return s3
c0 (0 -> 0):
return
c1 (0 -> 0):
return
maxInt3 (0 -> 0):
s0 <- call global maxInt p0 p1
s1 <- call global maxInt s0 p2
return s1
maxInts (0 -> 0):
s0 <- act c0
s1 <- call global foldl1 s0 p0
return s1
c0 (0 -> 0):
s0 <- call global maxInt p0 p1
return s0
minInt (0 -> 0):
s0 <- call global < p0 p1
s1 <- act c0
s2 <- act c1
s3 <- ifElse s2 s1 s0
return s3
c0 (0 -> 0):
return
c1 (0 -> 0):
return
minInt3 (0 -> 0):
s0 <- call global minInt p0 p1
s1 <- call global minInt s0 p2
return s1
minInts (0 -> 0):
s0 <- act c0
s1 <- call global foldl1 s0 p0
return s1
c0 (0 -> 0):
s0 <- call global minInt p0 p1
return s0
neChar (0 -> 0):
s0 <- act c0
s1 s2 <- call global toBoth s0 p0 p1
s3 <- call global != s2 s1
return s3
c0 (0 -> 0):
s0 <- call global charToInt p0
return s0
negFloat (0 -> 0):
s0 <- negFloat p0
return s0
negInt (0 -> 0):
s0 <- negInt p0
return s0
newline (0 -> 0):
s0 <- char '\n'
s1 <- vector s0
<- call global print s1
return
none (0 -> 0):
s0 <- none
return s0
noop (0 -> 0):
Impure
return
not (0 -> 0):
s0 <- notBool p0
return s0
oddFloat (0 -> 0):
s0 <- call global evenFloat p0
s1 <- call global not s0
return s1
oddInt (0 -> 0):
s0 <- call global evenInt p0
s1 <- call global not s0
return s1
openInput (0 -> 0):
s0 <- openIn
return s0
openOutput (0 -> 0):
s0 <- openOut
return s0
or (0 -> 0):
s0 <- bool false
s1 <- act c0
s2 <- call global foldl s1 s0 p0
return s2
c0 (0 -> 0):
s0 <- call global || p0 p1
return s0
pair (0 -> 0):
s0 <- pair p0 p1
return s0
pass (0 -> 0):
return
permutations (0 -> 0):
s0 <- vector
s1 <- vector s0
s2 <- act c0
s3 <- call global foldl s2 s1 p0
return s3
c0 (0 -> 0):
s0 <- act c0
s1 <- call global mapConcat s0 p1
return s1
c0 (0 -> 0):
s0 <- call global insertEverywhere p0 p1
return s0
pi (0 -> 0):
s0 <- float 3.141592653589793
return s0
prepend (0 -> 0):
s0 <- call global vector p0
s1 <- call global cat p1 s0
return s1
prependToAll (0 -> 0):
s0 <- call global head p1
s1 <- act c0
s2 <- act c1
s3 <- optionElse s2 s1 s0
return s3
c0 (0 -> 0):
s0 <- call global tail p1
s1 <- call global prependToAll s0 p2
s2 <- call global prepend p0 s1
s3 <- call global prepend s2 p3
return s3
c1 (0 -> 0):
s0 <- vector
return s0
print (0 -> 0):
s0 <- call global stdout
s1 <- print s0
return s1
printBool (0 -> 0):
s0 <- call global showBool p0
<- call global print s0
return
printBools (0 -> 0):
s0 <- call global showBools p0
<- call global print s0
return
printFloat (0 -> 0):
s0 <- call global showFloat p0
<- call global print s0
return
printFloats (0 -> 0):
s0 <- call global showFloats p0
<- call global print s0
return
printInt (0 -> 0):
s0 <- call global showInt p0
<- call global print s0
return
printInts (0 -> 0):
s0 <- call global showInts p0
<- call global print s0
return
printStrings (0 -> 0):
s0 <- call global showStrings p0
<- call global print s0
return
productFloats (0 -> 0):
s0 <- float 1.0
s1 <- act c0
s2 <- call global foldl s1 s0 p0
return s2
c0 (0 -> 0):
s0 <- call global *. p0 p1
return s0
productInts (0 -> 0):
s0 <- int 1
s1 <- act c0
s2 <- call global foldl s1 s0 p0
return s2
c0 (0 -> 0):
s0 <- call global * p0 p1
return s0
prompt (0 -> 0):
<- call global print p0
s0 <- call global getLine
return s0
rangeFor (0 -> 0):
<- apply p0
s0 <- act c0
s1 <- act c1
s2 <- ifElse s1 s0 p2
return p3 s2
c0 (0 -> 0):
s0 <- vector
return s0
c1 (0 -> 0):
<- apply p0
s0 <- call global rangeFor p1 p2 p3 p4
s1 <- call global prepend s0 p5
return s1
rangeTo (0 -> 0):
s0 <- call global < p0 p1
s1 <- act c0
s2 <- act c1
s3 <- ifElse s2 s1 s0
return s3
c0 (0 -> 0):
s0 <- act c0
s1 <- act c1
s2 <- call global rangeFor s1 s0 p0 p1
return s2
c0 (0 -> 0):
s0 <- call global ++ p0
return s0
c1 (0 -> 0):
s0 <- call global > p0 p1
return s0
c1 (0 -> 0):
s0 <- act c0
s1 <- act c1
s2 <- call global rangeFor s1 s0 p0 p1
return s2
c0 (0 -> 0):
s0 <- call global -- p0
return s0
c1 (0 -> 0):
s0 <- call global < p0 p1
return s0
rangeUntil (0 -> 0):
s0 <- call global < p0 p1
s1 <- act c0
s2 <- act c1
s3 <- ifElse s2 s1 s0
return s3
c0 (0 -> 0):
s0 <- act c0
s1 <- act c1
s2 <- call global rangeFor s1 s0 p0 p1
return s2
c0 (0 -> 0):
s0 <- call global ++ p0
return s0
c1 (0 -> 0):
s0 <- call global >= p0 p1
return s0
c1 (0 -> 0):
s0 <- act c0
s1 <- act c1
s2 <- call global rangeFor s1 s0 p0 p1
return s2
c0 (0 -> 0):
s0 <- call global -- p0
return s0
c1 (0 -> 0):
s0 <- call global <= p0 p1
return s0
readInt (0 -> 0):
s0 <- call global none
s1 <- call global last p0
s2 <- act c0
s3 <- option s2 s1
return s0 s3
c0 (0 -> 0):
s0 <- act c0
s1 <- act c1
s2 s3 <- call global bothTo s1 s0 p0
s4 <- call global && s3 s2
s5 <- act c2
s6 <- if s5 s4
return s6
c0 (0 -> 0):
s0 <- char '0'
s1 <- call global geChar s0 p0
return s1
c1 (0 -> 0):
s0 <- char '9'
s1 <- call global leChar s0 p0
return s1
c2 (0 -> 0):
<- call global drop p0
s0 <- char '0'
s1 <- act c0
s2 s3 <- call global toBoth s1 s0 p1
s4 <- call global - s3 s2
s5 <- call global init s4
s6 <- call global readInt s5
s7 <- act c1
s8 <- option s7 s6
s9 <- call global some s8
return s9
c0 (0 -> 0):
s0 <- call global charToInt p0
return s0
c1 (0 -> 0):
s0 <- int 10
s1 <- call global * s0 p0
s2 <- call global + s1 p1
return s2
replicate (0 -> 0):
s0 <- int 0
s1 <- call global <= s0 p0
s2 <- act c0
s3 <- act c1
s4 <- ifElse s3 s2 s1
return s4
c0 (0 -> 0):
s0 <- vector
return s0
c1 (0 -> 0):
s0 <- call global -- p0
s1 <- call global replicate s0 p1
s2 <- call global prepend s1 p2
return s2
rest (0 -> 0):
s0 <- rest p0
return s0
reverse (0 -> 0):
s0 <- call global last p0
s1 <- act c0
s2 <- act c1
s3 <- optionElse s2 s1 s0
return s3
c0 (0 -> 0):
s0 <- call global init p1
s1 <- call global reverse s0
s2 <- call global prepend p0 s1
return s2
c1 (0 -> 0):
s0 <- vector
return s0
right (0 -> 0):
s0 <- makeRight p0
return s0
say (0 -> 0):
<- call global print p0
<- call global newline
return
sayBool (0 -> 0):
<- call global printBool p0
<- call global newline
return
sayBools (0 -> 0):
<- call global printBools p0
<- call global newline
return
sayFloat (0 -> 0):
<- call global printFloat p0
<- call global newline
return
sayFloats (0 -> 0):
<- call global printFloats p0
<- call global newline
return
sayInt (0 -> 0):
<- call global printInt p0
<- call global newline
return
sayInts (0 -> 0):
<- call global printInts p0
<- call global newline
return
sayStrings (0 -> 0):
<- call global printStrings p0
<- call global newline
return
scanl (0 -> 0):
s0 <- call global scanlRest p0 p1 p2
s1 <- call global prepend p1 s0
return s1
scanl1 (0 -> 0):
s0 <- call global tail p1
s1 <- call global unsafeHead p1
s2 <- call global scanl p0 s1 s0
return s2
scanlRest (0 -> 0):
s0 <- call global head p2
s1 <- act c0
s2 <- act c1
s3 <- optionElse s2 s1 s0
return s3
c0 (0 -> 0):
<- apply p0
s0 <- call global tail p2
s1 <- call global scanlRest p1 s0 p3
s2 <- call global prepend p1 s1
return s2
c1 (0 -> 0):
s0 <- vector
return s0
scanr (0 -> 0):
s0 <- call global head p2
s1 <- act c0
s2 <- act c1
s3 <- optionElse s2 s1 s0
return s3
c0 (0 -> 0):
s0 <- call global tail p1
s1 <- call global scanr s0 p2 p3
s2 s3 <- call global dup s1
s4 <- call global unsafeHead s3
s5 s6 <- call global swap p0 s4
<- apply s6
s7 <- call global prepend s5 s2
return s7
c1 (0 -> 0):
s0 <- vector p0
return s0
scanr1 (0 -> 0):
s0 <- call global init p1
s1 <- call global unsafeLast p1
s2 <- call global scanr p0 s1 s0
return s2
second (0 -> 0):
s0 <- call global rest p0
s1 <- call global first s0
return s1
showBool (0 -> 0):
s0 <- act c0
s1 <- act c1
s2 <- ifElse s1 s0 p0
return s2
c0 (0 -> 0):
s0 <- char 't'
s1 <- char 'r'
s2 <- char 'u'
s3 <- char 'e'
s4 <- vector s0 s1 s2 s3
return s4
c1 (0 -> 0):
s0 <- char 'f'
s1 <- char 'a'
s2 <- char 'l'
s3 <- char 's'
s4 <- char 'e'
s5 <- vector s0 s1 s2 s3 s4
return s5
showBools (0 -> 0):
s0 <- act c0
s1 <- call global showVector s0 p0
return s1
c0 (0 -> 0):
s0 <- call global showBool p0
return s0
showFloat (0 -> 0):
s0 <- showFloat p0
return s0
showFloats (0 -> 0):
s0 <- act c0
s1 <- call global showVector s0 p0
return s1
c0 (0 -> 0):
s0 <- call global showFloat p0
return s0
showInt (0 -> 0):
s0 <- showInt p0
return s0
showInts (0 -> 0):
s0 <- act c0
s1 <- call global showVector s0 p0
return s1
c0 (0 -> 0):
s0 <- call global showInt p0
return s0
showStrings (0 -> 0):
s0 <- act c0
s1 <- call global showVector s0 p0
return s1
c0 (0 -> 0):
s0 <- call global id p0
return s0
showVector (0 -> 0):
s0 <- char '['
s1 <- vector s0
s2 <- call global map p0 p1
s3 <- char ','
s4 <- char ' '
s5 <- vector s3 s4
s6 <- call global join s5 s2
s7 <- char ']'
s8 <- vector s7
s9 <- vector s1 s6 s8
s10 <- call global concat s9
return s10
some (0 -> 0):
s0 <- some p0
return s0
sort (0 -> 0):
s0 <- vector
s1 <- act c0
s2 <- call global foldl s1 s0 p1
return s2
c0 (0 -> 0):
s0 <- call global insert p0 p1 p2
return s0
space (0 -> 0):
s0 <- char ' '
s1 <- vector s0
<- call global print s1
return
span (0 -> 0):
s0 <- call global keepWhile p0 p1
s1 <- call global tossWhile p0 p1
return s0 s1
splitAt (0 -> 0):
s0 <- call global keep p0 p1
s1 <- call global toss p0 p1
return s0 s1
stderr (0 -> 0):
s0 <- stderr
return s0
stdin (0 -> 0):
s0 <- stdin
return s0
stdout (0 -> 0):
s0 <- stdout
return s0
sumFloats (0 -> 0):
s0 <- float 0.0
s1 <- act c0
s2 <- call global foldl s1 s0 p0
return s2
c0 (0 -> 0):
s0 <- call global +. p0 p1
return s0
sumInts (0 -> 0):
s0 <- int 0
s1 <- act c0
s2 <- call global foldl s1 s0 p0
return s2
c0 (0 -> 0):
s0 <- call global + p0 p1
return s0
swap (0 -> 0):
return p0 p1
tab (0 -> 0):
s0 <- char '\t'
s1 <- vector s0
<- call global print s1
return
tail (0 -> 0):
s0 <- tail p0
return s0
tau (0 -> 0):
s0 <- float 6.283185307179586
return s0
third (0 -> 0):
s0 <- call global rest p0
s1 <- call global rest s0
s2 <- call global first s1
return s2
toBoth (0 -> 0):
<- apply p0
<- apply p0
return p2 p1
toss (0 -> 0):
s0 <- int 0
s1 <- call global <= s0 p0
s2 <- call global isEmpty p1
s3 <- call global || s2 s1
s4 <- act c0
s5 <- act c1
s6 <- ifElse s5 s4 s3
return s6
c0 (0 -> 0):
return
c1 (0 -> 0):
s0 <- call global tail p0
s1 <- call global -- s0
s2 <- call global toss s1 p1
return s2
tossWhile (0 -> 0):
s0 <- call global head p1
s1 <- act c0
s2 <- option s1 s0
return p1 s2
c0 (0 -> 0):
<- apply p0
s0 <- act c0
s1 <- if s0 p1
return s1
c0 (0 -> 0):
s0 <- call global tail p0
s1 <- call global tossWhile s0 p1
return s1
transpose (0 -> 0):
s0 <- call global isEmpty p0
s1 <- act c0
s2 <- act c1
s3 <- ifElse s2 s1 s0
return s3
c0 (0 -> 0):
s0 <- vector
return s0
c1 (0 -> 0):
s0 <- call global unsafeHead p0
s1 <- call global isEmpty s0
s2 <- act c0
s3 <- act c1
s4 <- ifElse s3 s2 s1
return s4
c0 (0 -> 0):
s0 <- call global tail p0
s1 <- call global transpose s0
return s1
c1 (0 -> 0):
s0 s1 <- call global unsafeHeadTail p0
s2 s3 <- call global unsafeHeadTail s0
s4 <- act c0
s5 <- call global map s4 s1
s6 <- call global prepend s3 s5
s7 <- call global transpose s6
s8 <- act c1
s9 <- call global map s8 s1
s10 <- call global prepend s2 s9
s11 <- call global prepend s10 s7
return s11
c0 (0 -> 0):
s0 <- call global tail p0
return s0
c1 (0 -> 0):
s0 <- call global unsafeHead p0
return s0
unique (0 -> 0):
s0 <- call global head p1
s1 <- act c0
s2 <- act c1
s3 <- optionElse s2 s1 s0
return s3
c0 (0 -> 0):
s0 <- call global tail p1
s1 <- act c0
s2 <- call global filter s1 s0
s3 <- call global unique s2 p2
s4 <- call global prepend p0 s3
return s4
c0 (0 -> 0):
<- apply p0
s0 <- call global not p1
return s0
c1 (0 -> 0):
s0 <- vector
return s0
unsafeCall11 (0 -> 0):
s0 <- call global unsafePurify11 p0
<- apply s0
return
unsafeHead (0 -> 0):
s0 <- call global head p0
s1 <- call global fromSome s0
return s1
unsafeHeadTail (0 -> 0):
s0 <- act c0
s1 <- act c1
s2 s3 <- call global bothTo s1 s0 p0
return s2 s3
c0 (0 -> 0):
s0 <- call global unsafeHead p0
return s0
c1 (0 -> 0):
s0 <- call global tail p0
return s0
unsafeLast (0 -> 0):
s0 <- call global last p0
s1 <- call global fromSome s0
return s1
unsafePurify11 (0 -> 0):
s0 <- unsafePurify11 p0
return s0
until (0 -> 0):
<- apply p0
s0 <- act c0
s1 <- act c1
s2 <- ifElse s1 s0 p2
return s2
c0 (0 -> 0):
return
c1 (0 -> 0):
<- apply p0
s0 <- call global until p1 p2 p3
return s0
vector (0 -> 0):
s0 <- vector p0
return s0
zip (0 -> 0):
s0 <- act c0
s1 <- call global zipWith s0 p0 p1
return s1
c0 (0 -> 0):
s0 <- call global pair p0 p1
return s0
zipWith (0 -> 0):
s0 <- vector
s1 <- call global head p2
s2 <- act c0
s3 <- option s2 s1
return s0 s3
c0 (0 -> 0):
s0 <- call global head p1
s1 <- act c0
s2 <- option s1 s0
return s2
c0 (0 -> 0):
<- call global drop p1
s0 <- call global tail p2
s1 <- call global tail s0
s2 <- call global zipWith s1 p3 p4
<- apply p0
s3 <- call global prepend s2 p5
return s3
| (0 -> 0):
s0 <- orInt p0 p1
return s0
|| (0 -> 0):
s0 <- orBool p0 p1
return s0
~ (0 -> 0):
s0 <- notInt p0
return s0
¬ (0 -> 0):
s0 <- notBool p0
return s0
× (0 -> 0):
s0 <- mulInt p0 p1
return s0
×. (0 -> 0):
s0 <- mulFloat p0 p1
return s0
÷ (0 -> 0):
s0 <- divInt p0 p1
return s0
÷. (0 -> 0):
s0 <- divFloat p0 p1
return s0
− (0 -> 0):
s0 <- subInt p0 p1
return s0
−. (0 -> 0):
s0 <- subFloat p0 p1
return s0
∧ (0 -> 0):
s0 <- andBool p0 p1
return s0
∨ (0 -> 0):
s0 <- orBool p0 p1
return s0
≠ (0 -> 0):
s0 <- neInt p0 p1
return s0
≠. (0 -> 0):
s0 <- neFloat p0 p1
return s0
≤ (0 -> 0):
s0 <- leInt p0 p1
return s0
≤. (0 -> 0):
s0 <- leFloat p0 p1
return s0
≥ (0 -> 0):
s0 <- geInt p0 p1
return s0
≥. (0 -> 0):
s0 <- geFloat p0 p1
return s0
top-level (0 -> 0):
s0 <- char 'H'
s1 <- char 'e'
s2 <- char 'l'
s3 <- char 'l'
s4 <- char 'o'
s5 <- char ','
s6 <- char ' '
s7 <- char 'w'
s8 <- char 'o'
s9 <- char 'r'
s10 <- char 'l'
s11 <- char 'd'
s12 <- char '!'
s13 <- vector s0 s1 s2 s3 s4 s5 s6 s7 s8 s9 s10 s11 s12
<- call global say s13
return
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment