summaryrefslogtreecommitdiff
path: root/old-lib/prelude
diff options
context:
space:
mode:
Diffstat (limited to 'old-lib/prelude')
-rw-r--r--old-lib/prelude/Coordination.gf129
-rw-r--r--old-lib/prelude/Formal.gf54
-rw-r--r--old-lib/prelude/HTML.gf8
-rw-r--r--old-lib/prelude/Latex.gf12
-rw-r--r--old-lib/prelude/Precedence.gf117
-rw-r--r--old-lib/prelude/Predef.gf37
-rw-r--r--old-lib/prelude/PredefAbs.gf4
-rw-r--r--old-lib/prelude/PredefCnc.gf4
-rw-r--r--old-lib/prelude/Prelude.gf142
9 files changed, 0 insertions, 507 deletions
diff --git a/old-lib/prelude/Coordination.gf b/old-lib/prelude/Coordination.gf
deleted file mode 100644
index 499b45306..000000000
--- a/old-lib/prelude/Coordination.gf
+++ /dev/null
@@ -1,129 +0,0 @@
-resource Coordination = open Prelude in {
-
-param
- ListSize = TwoElem | ManyElem ;
-
-oper
- ListX = {s1,s2 : Str} ;
-
- twoStr : (x,y : Str) -> ListX = \x,y ->
- {s1 = x ; s2 = y} ;
- consStr : Str -> ListX -> Str -> ListX = \comma,xs,x ->
- {s1 = xs.s1 ++ comma ++ xs.s2 ; s2 = x } ;
-
- twoSS : (_,_ : SS) -> ListX = \x,y ->
- twoStr x.s y.s ;
- consSS : Str -> ListX -> SS -> ListX = \comma,xs,x ->
- consStr comma xs x.s ;
-
- Conjunction : Type = SS ;
- ConjunctionDistr : Type = {s1 : Str ; s2 : Str} ;
-
- conjunctX : Conjunction -> ListX -> Str = \or,xs ->
- xs.s1 ++ or.s ++ xs.s2 ;
-
- conjunctDistrX : ConjunctionDistr -> ListX -> Str = \or,xs ->
- or.s1 ++ xs.s1 ++ or.s2 ++ xs.s2 ;
-
- conjunctSS : Conjunction -> ListX -> SS = \or,xs ->
- ss (xs.s1 ++ or.s ++ xs.s2) ;
-
- conjunctDistrSS : ConjunctionDistr -> ListX -> SS = \or,xs ->
- ss (or.s1 ++ xs.s1 ++ or.s2 ++ xs.s2) ;
-
- -- all this lifted to tables
-
- ListTable : Type -> Type = \P -> {s1,s2 : P => Str} ;
-
- twoTable : (P : Type) -> (_,_ : {s : P => Str}) -> ListTable P = \_,x,y ->
- {s1 = x.s ; s2 = y.s} ;
-
- consTable : (P : Type) -> Str -> ListTable P -> {s : P => Str} -> ListTable P =
- \P,c,xs,x ->
- {s1 = table P {o => xs.s1 ! o ++ c ++ xs.s2 ! o} ; s2 = x.s} ;
-
- conjunctTable : (P : Type) -> Conjunction -> ListTable P -> {s : P => Str} =
- \P,or,xs ->
- {s = table P {p => xs.s1 ! p ++ or.s ++ xs.s2 ! p}} ;
-
- conjunctDistrTable :
- (P : Type) -> ConjunctionDistr -> ListTable P -> {s : P => Str} = \P,or,xs ->
- {s = table P {p => or.s1++ xs.s1 ! p ++ or.s2 ++ xs.s2 ! p}} ;
-
- -- ... and to two- and three-argument tables: how clumsy! ---
-
- ListTable2 : Type -> Type -> Type = \P,Q ->
- {s1,s2 : P => Q => Str} ;
-
- twoTable2 : (P,Q : Type) -> (_,_ : {s : P => Q => Str}) -> ListTable2 P Q =
- \_,_,x,y ->
- {s1 = x.s ; s2 = y.s} ;
-
- consTable2 :
- (P,Q : Type) -> Str -> ListTable2 P Q -> {s : P => Q => Str} -> ListTable2 P Q =
- \P,Q,c,xs,x ->
- {s1 = table P {p => table Q {q => xs.s1 ! p ! q ++ c ++ xs.s2 ! p! q}} ;
- s2 = x.s
- } ;
-
- conjunctTable2 :
- (P,Q : Type) -> Conjunction -> ListTable2 P Q -> {s : P => Q => Str} =
- \P,Q,or,xs ->
- {s = table P {p => table Q {q => xs.s1 ! p ! q ++ or.s ++ xs.s2 ! p ! q}}} ;
-
- conjunctDistrTable2 :
- (P,Q : Type) -> ConjunctionDistr -> ListTable2 P Q -> {s : P => Q => Str} =
- \P,Q,or,xs ->
- {s =
- table P {p => table Q {q => or.s1++ xs.s1 ! p ! q ++ or.s2 ++ xs.s2 ! p ! q}}} ;
-
- ListTable3 : Type -> Type -> Type -> Type = \P,Q,R ->
- {s1,s2 : P => Q => R => Str} ;
-
- twoTable3 : (P,Q,R : Type) -> (_,_ : {s : P => Q => R => Str}) ->
- ListTable3 P Q R =
- \_,_,_,x,y ->
- {s1 = x.s ; s2 = y.s} ;
-
- consTable3 :
- (P,Q,R : Type) -> Str -> ListTable3 P Q R -> {s : P => Q => R => Str} ->
- ListTable3 P Q R =
- \P,Q,R,c,xs,x ->
- {s1 = \\p,q,r => xs.s1 ! p ! q ! r ++ c ++ xs.s2 ! p ! q ! r ;
- s2 = x.s
- } ;
-
- conjunctTable3 :
- (P,Q,R : Type) -> Conjunction -> ListTable3 P Q R -> {s : P => Q => R => Str} =
- \P,Q,R,or,xs ->
- {s = \\p,q,r => xs.s1 ! p ! q ! r ++ or.s ++ xs.s2 ! p ! q ! r} ;
-
- conjunctDistrTable3 :
- (P,Q,R : Type) -> ConjunctionDistr -> ListTable3 P Q R ->
- {s : P => Q => R => Str} =
- \P,Q,R,or,xs ->
- {s = \\p,q,r => or.s1++ xs.s1 ! p ! q ! r ++ or.s2 ++ xs.s2 ! p ! q ! r} ;
-
- comma = "," ;
-
--- you can also do this to right-associative lists:
-
- consrStr : Str -> Str -> ListX -> ListX = \comma,x,xs ->
- {s1 = x ++ comma ++ xs.s1 ; s2 = xs.s2 } ;
-
- consrSS : Str -> SS -> ListX -> ListX = \comma,x,xs ->
- consrStr comma x.s xs ;
-
- consrTable : (P : Type) -> Str -> {s : P => Str} -> ListTable P -> ListTable P =
- \P,c,x,xs ->
- {s1 = table P {o => x.s ! o ++ c ++ xs.s1 ! o} ; s2 = xs.s2} ;
-
- consrTable2 : (P,Q : Type) -> Str -> {s : P => Q => Str} ->
- ListTable2 P Q -> ListTable2 P Q =
- \P,Q,c,x,xs ->
- {s1 = table P {p => table Q {q => x.s ! p ! q ++ c ++ xs.s1 ! p ! q}} ;
- s2 = xs.s2
- } ;
-
-
-} ;
diff --git a/old-lib/prelude/Formal.gf b/old-lib/prelude/Formal.gf
deleted file mode 100644
index 2aa33d9ef..000000000
--- a/old-lib/prelude/Formal.gf
+++ /dev/null
@@ -1,54 +0,0 @@
-resource Formal = open Prelude in {
-
--- to replace the old library Precedence
-
- oper
- Prec : PType ;
- TermPrec : Type = {s : Str ; p : Prec} ;
-
- mkPrec : Prec -> Str -> TermPrec = \p,s ->
- {s = s ; p = p} ;
-
- top : TermPrec -> Str = usePrec 0 ;
-
- constant : Str -> TermPrec = mkPrec highest ;
-
- infixl : Prec -> Str -> (_,_ : TermPrec) -> TermPrec = \p,f,x,y ->
- mkPrec p (usePrec p x ++ f ++ usePrec (nextPrec p) y) ;
- infixr : Prec -> Str -> (_,_ : TermPrec) -> TermPrec = \p,f,x,y ->
- mkPrec p (usePrec (nextPrec p) x ++ f ++ usePrec p y) ;
- infixn : Prec -> Str -> (_,_ : TermPrec) -> TermPrec = \p,f,x,y ->
- mkPrec p (usePrec (nextPrec p) x ++ f ++ usePrec (nextPrec p) y) ;
-
--- auxiliaries, should not be needed so much
-
- usePrec : Prec -> TermPrec -> Str = \p,x ->
- case lessPrec x.p p of {
- True => parenth x.s ;
- False => parenthOpt x.s
- } ;
-
- parenth : Str -> Str = \s -> "(" ++ s ++ ")" ;
- parenthOpt : Str -> Str = \s -> variants {s ; "(" ++ s ++ ")"} ;
-
---.
--- low-level things: don't use
-
- Prec : PType = Predef.Ints 4 ;
-
- highest = 4 ;
-
- lessPrec : Prec -> Prec -> Bool = \p,q ->
- case <<p,q> : Prec * Prec> of {
- <3,4> | <2,3> | <2,4> => True ;
- <1,1> | <1,0> | <0,0> => False ;
- <1,_> | <0,_> => True ;
- _ => False
- } ;
-
- nextPrec : Prec -> Prec = \p -> case <p : Prec> of {
- 4 => 4 ;
- n => Predef.plus n 1
- } ;
-
-}
diff --git a/old-lib/prelude/HTML.gf b/old-lib/prelude/HTML.gf
deleted file mode 100644
index b469b582c..000000000
--- a/old-lib/prelude/HTML.gf
+++ /dev/null
@@ -1,8 +0,0 @@
-resource HTML = open Prelude in {
- oper
- tag : Str -> Str = \t -> "<" + t + ">" ;
- endtag : Str -> Str = \t -> tag ("/" + t) ;
- intag : Str -> Str -> Str = \t,s -> tag t ++ s ++ endtag t ;
- intagAttr : Str -> Str -> Str -> Str =
- \t,a,s -> ("<" + t) ++ (a + ">") ++ s ++ endtag t ;
-}
diff --git a/old-lib/prelude/Latex.gf b/old-lib/prelude/Latex.gf
deleted file mode 100644
index 2fd2f9ec8..000000000
--- a/old-lib/prelude/Latex.gf
+++ /dev/null
@@ -1,12 +0,0 @@
-resource Latex = open Prelude in {
- oper
- command : Str -> Str = \c -> "\\" + c ;
- fun1 : Str -> Str -> Str = \f,x -> "\\" + f + "{" ++ x ++ "}" ;
- fun2 : Str -> Str -> Str -> Str =
- \f,x,y -> "\\" + f + "{" ++ x ++ "}{" ++ y ++ "}" ;
- begin : Str -> Str = \e -> "\\begin{" + e + "}" ;
- end : Str -> Str = \e -> "\\end{" + e + "}" ;
- inEnv : Str -> Str -> Str = \e,s -> begin e ++ s ++ end e ;
-}
-
-
diff --git a/old-lib/prelude/Precedence.gf b/old-lib/prelude/Precedence.gf
deleted file mode 100644
index 62775958c..000000000
--- a/old-lib/prelude/Precedence.gf
+++ /dev/null
@@ -1,117 +0,0 @@
--- operations for precedence-dependent strings.
--- five levels:
--- p4 (constants), p3 (applications), p2 (products), p1 (sums), p0 (arrows)
-
-resource Precedence = open Prelude in {
-
-param
-Prec = p4 | p3 | p2 | p1 | p0 ;
-
-oper
-PrecTerm = Prec => Str ;
-
-oper
-pss : PrecTerm -> {s : PrecTerm} = \s -> {s = s} ;
-
-
--- change this if you want some other type of parentheses
-mkParenth : Str -> Str = \str -> "(" ++ str ++ ")" ;
-
--- define ordering of precedences
-nextPrec : Prec => Prec =
- table {p0 => p1 ; p1 => p2 ; p2 => p3 ; _ => p4} ;
-prevPrec : Prec => Prec =
- table {p4 => p3 ; p3 => p2 ; p2 => p1 ; _ => p0} ;
-
-mkPrec : Str -> Prec => Prec => Str = \str ->
- table {
- p4 => table { -- use the term of precedence p4...
- _ => str} ; -- ...always without parentheses
- p3 => table { -- use the term of precedence p3...
- p4 => mkParenth str ; -- ...in parentheses if p4 is required...
- _ => str} ; -- ...otherwise without parentheses
- p2 => table {
- p4 => mkParenth str ;
- p3 => mkParenth str ;
- _ => str} ;
- p1 => table {
- p1 => str ;
- p0 => str ;
- _ => mkParenth str} ;
- p0 => table {
- p0 => str ;
- _ => mkParenth str}
- } ;
-
--- make a string into a constant, of precedence p4
-mkConst : Str -> PrecTerm =
- \f ->
- mkPrec f ! p4 ;
-
--- make a string into a 1/2/3 -place prefix operator, of precedence p3
-mkFun1 : Str -> PrecTerm -> PrecTerm =
- \f -> \x ->
- table {k => mkPrec (f ++ x ! p4) ! p3 ! k} ;
-mkFun2 : Str -> PrecTerm -> PrecTerm -> PrecTerm =
- \f -> \x -> \y ->
- table {k => mkPrec (f ++ x ! p4 ++ y ! p4) ! p3 ! k} ;
-mkFun3 : Str -> PrecTerm -> PrecTerm -> PrecTerm -> PrecTerm =
- \f -> \x -> \y -> \z ->
- table {k => mkPrec (f ++ x ! p4 ++ y ! p4 ++ z ! p4) ! p3 ! k} ;
-
--- make a string into a non/left/right -associative infix operator, of precedence p
-mkInfix : Str -> Prec -> PrecTerm -> PrecTerm -> PrecTerm =
- \f -> \p -> \x -> \y ->
- table {k => mkPrec (x ! (nextPrec ! p) ++ f ++ y ! (nextPrec ! p)) ! p ! k} ;
-mkInfixL : Str -> Prec -> PrecTerm -> PrecTerm -> PrecTerm =
- \f -> \p -> \x -> \y ->
- table {k => mkPrec (x ! p ++ f ++ y ! (nextPrec ! p)) ! p ! k} ;
-mkInfixR : Str -> Prec -> PrecTerm -> PrecTerm -> PrecTerm =
- \f -> \p -> \x -> \y ->
- table {k => mkPrec (x ! (nextPrec ! p) ++ f ++ y ! p) ! p ! k} ;
-
------------------------------------------------------------
-
--- alternative:
--- precedence as inherent feature
-
-oper TermWithPrec = {s : Str ; p : Prec} ;
-
-oper
-mkpPrec : Str -> Prec -> TermWithPrec =
- \f -> \p ->
- {s = f ; p = p} ;
-
-usePrec : TermWithPrec -> Prec -> Str =
- \x -> \p ->
- mkPrec x.s ! x.p ! p ;
-
--- make a string into a constant, of precedence p4
-mkpConst : Str -> TermWithPrec =
- \f ->
- mkpPrec f p4 ;
-
--- make a string into a 1/2/3 -place prefix operator, of precedence p3
-mkpFun1 : Str -> TermWithPrec -> TermWithPrec =
- \f -> \x ->
- mkpPrec (f ++ usePrec x p4) p3 ;
-
-mkpFun2 : Str -> TermWithPrec -> TermWithPrec -> TermWithPrec =
- \f -> \x -> \y ->
- mkpPrec (f ++ usePrec x p4 ++ usePrec y p4) p3 ;
-
-mkpFun3 : Str -> TermWithPrec -> TermWithPrec -> TermWithPrec -> TermWithPrec =
- \f -> \x -> \y -> \z ->
- mkpPrec (f ++ usePrec x p4 ++ usePrec y p4 ++ usePrec z p4) p3 ;
-
--- make a string a into non/left/right -associative infix operator, of precedence p
-mkpInfix : Str -> Prec -> TermWithPrec -> TermWithPrec -> TermWithPrec =
- \f -> \p -> \x -> \y ->
- mkpPrec (usePrec x (nextPrec ! p) ++ f ++ usePrec y (nextPrec ! p)) p ;
-mkpInfixL : Str -> Prec -> TermWithPrec -> TermWithPrec -> TermWithPrec =
- \f -> \p -> \x -> \y ->
- mkpPrec (usePrec x p ++ f ++ usePrec y (nextPrec ! p)) p ;
-mkpInfixR : Str -> Prec -> TermWithPrec -> TermWithPrec -> TermWithPrec =
- \f -> \p -> \x -> \y ->
- mkpPrec (usePrec x (nextPrec ! p) ++ f ++ usePrec y p) p ;
-} ; \ No newline at end of file
diff --git a/old-lib/prelude/Predef.gf b/old-lib/prelude/Predef.gf
deleted file mode 100644
index d8141ea8c..000000000
--- a/old-lib/prelude/Predef.gf
+++ /dev/null
@@ -1,37 +0,0 @@
---1 Predefined functions for concrete syntax
-
--- The definitions of these constants are hard-coded in GF, and defined
--- in [AppPredefined.hs ../src/GF/Grammar/AppPredefined.hs]. Applying
--- them to run-time variables leads to compiler errors that are often
--- only detected at the code generation time.
-
-resource Predef = {
-
--- This type of booleans is for internal use only.
-
- param PBool = PTrue | PFalse ;
-
- oper Error : Type = variants {} ; -- the empty type
- oper Int : Type = variants {} ; -- the type of integers
- oper Ints : Int -> Type = variants {} ; -- the type of integers from 0 to n
-
- oper error : Str -> Error = variants {} ; -- forms error message
- oper length : Tok -> Int = variants {} ; -- length of string
- oper drop : Int -> Tok -> Tok = variants {} ; -- drop prefix of length
- oper take : Int -> Tok -> Tok = variants {} ; -- take prefix of length
- oper tk : Int -> Tok -> Tok = variants {} ; -- drop suffix of length
- oper dp : Int -> Tok -> Tok = variants {} ; -- take suffix of length
- oper eqInt : Int -> Int -> PBool = variants {} ; -- test if equal integers
- oper lessInt: Int -> Int -> PBool = variants {} ; -- test order of integers
- oper plus : Int -> Int -> Int = variants {} ; -- add integers
- oper eqStr : Tok -> Tok -> PBool = variants {} ; -- test if equal strings
- oper occur : Tok -> Tok -> PBool = variants {} ; -- test if occurs as substring
- oper occurs : Tok -> Tok -> PBool = variants {} ; -- test if any char occurs
- oper show : (P : Type) -> P -> Tok = variants {} ; -- convert param to string
- oper read : (P : Type) -> Tok -> P = variants {} ; -- convert string to param
- oper toStr : (L : Type) -> L -> Str = variants {} ; -- find the "first" string
- oper mapStr : (L : Type) -> (Str -> Str) -> L -> L = variants {} ;
- -- map all strings in a data structure; experimental ---
-
-} ;
-
diff --git a/old-lib/prelude/PredefAbs.gf b/old-lib/prelude/PredefAbs.gf
deleted file mode 100644
index a99961d00..000000000
--- a/old-lib/prelude/PredefAbs.gf
+++ /dev/null
@@ -1,4 +0,0 @@
-abstract PredefAbs = {
- cat Int ; String ; Float ;
-} ;
-
diff --git a/old-lib/prelude/PredefCnc.gf b/old-lib/prelude/PredefCnc.gf
deleted file mode 100644
index f12b9b1f0..000000000
--- a/old-lib/prelude/PredefCnc.gf
+++ /dev/null
@@ -1,4 +0,0 @@
-concrete PredefCnc of PredefAbs = {
- lincat
- Int, Float, String = {s : Str} ;
-} ;
diff --git a/old-lib/prelude/Prelude.gf b/old-lib/prelude/Prelude.gf
deleted file mode 100644
index 56545d051..000000000
--- a/old-lib/prelude/Prelude.gf
+++ /dev/null
@@ -1,142 +0,0 @@
---1 The GF Prelude
-
--- This file defines some prelude facilities usable in all grammars.
-
-resource Prelude = open (Predef=Predef) in {
-
-oper
-
---2 Strings, records, and tables
-
- SS : Type = {s : Str} ;
- ss : Str -> SS = \s -> {s = s} ;
- ss2 : (_,_ : Str) -> SS = \x,y -> ss (x ++ y) ;
- ss3 : (_,_ ,_: Str) -> SS = \x,y,z -> ss (x ++ y ++ z) ;
-
- cc2 : (_,_ : SS) -> SS = \x,y -> ss (x.s ++ y.s) ;
- cc3 : (_,_,_ : SS) -> SS = \x,y,z -> ss (x.s ++ y.s ++ z.s) ;
-
- SS1 : Type -> Type = \P -> {s : P => Str} ;
- ss1 : (A : Type) -> Str -> SS1 A = \A,s -> {s = table {_ => s}} ;
-
- SP1 : Type -> Type = \P -> {s : Str ; p : P} ;
- sp1 : (A : Type) -> Str -> A -> SP1 A = \_,s,a -> {s = s ; p = a} ;
-
- constTable : (A,B : Type) -> B -> A => B = \_,_,b -> \\_ => b ;
- constStr : (A : Type) -> Str -> A => Str = \A -> constTable A Str ;
-
--- Discontinuous constituents.
-
- SD2 : Type = {s1,s2 : Str} ;
- sd2 : (_,_ : Str) -> SD2 = \x,y -> {s1 = x ; s2 = y} ;
-
-
---2 Optional elements
-
--- Missing form.
-
- nonExist : Str = variants {} ;
-
--- Optional string with preference on the string vs. empty.
-
- optStr : Str -> Str = \s -> variants {s ; []} ;
- strOpt : Str -> Str = \s -> variants {[] ; s} ;
-
--- Free order between two strings.
-
- bothWays : Str -> Str -> Str = \x,y -> variants {x ++ y ; y ++ x} ;
-
--- Parametric order between two strings.
-
- preOrPost : Bool -> Str -> Str -> Str = \pr,x,y ->
- if_then_Str pr (x ++ y) (y ++ x) ;
-
---2 Infixes. prefixes, and postfixes
-
--- Fixes with precedences are defined in [Precedence Precedence.html].
-
- infixSS : Str -> SS -> SS -> SS = \f,x,y -> ss (x.s ++ f ++ y.s) ;
- prefixSS : Str -> SS -> SS = \f,x -> ss (f ++ x.s) ;
- postfixSS : Str -> SS -> SS = \f,x -> ss (x.s ++ f) ;
- embedSS : Str -> Str -> SS -> SS = \f,g,x -> ss (f ++ x.s ++ g) ;
-
-
---2 Booleans
-
- param Bool = True | False ;
-
-oper
- if_then_else : (A : Type) -> Bool -> A -> A -> A = \_,c,d,e ->
- case c of {
- True => d ; ---- should not need to qualify
- False => e
- } ;
-
- andB : (_,_ : Bool) -> Bool = \a,b -> if_then_else Bool a b False ;
- orB : (_,_ : Bool) -> Bool = \a,b -> if_then_else Bool a True b ;
- notB : Bool -> Bool = \a -> if_then_else Bool a False True ;
-
- if_then_Str : Bool -> Str -> Str -> Str = if_then_else Str ;
-
- onlyIf : Bool -> Str -> Str = \b,s -> case b of {
- True => s ;
- _ => nonExist
- } ;
-
--- Interface to internal booleans
-
- pbool2bool : Predef.PBool -> Bool = \b -> case b of {
- Predef.PFalse => False ; Predef.PTrue => True
- } ;
-
- init : Tok -> Tok = Predef.tk 1 ;
- last : Tok -> Tok = Predef.dp 1 ;
-
---2 High-level acces to Predef operations
-
- isNil : Tok -> Bool = \b -> pbool2bool (Predef.eqStr [] b) ;
-
- ifTok : (A : Type) -> Tok -> Tok -> A -> A -> A = \A,t,u,a,b ->
- case Predef.eqStr t u of {Predef.PTrue => a ; Predef.PFalse => b} ;
-
---2 Lexer-related operations
-
--- Bind together two tokens in some lexers, either obligatorily or optionally
-
- oper
- glue : Str -> Str -> Str = \x,y -> x ++ BIND ++ y ;
- glueOpt : Str -> Str -> Str = \x,y -> variants {glue x y ; x ++ y} ;
- noglueOpt : Str -> Str -> Str = \x,y -> variants {x ++ y ; glue x y} ;
-
--- Force capitalization of next word in some unlexers
-
- capitalize : Str -> Str = \s -> CAPIT ++ s ;
-
--- These should be hidden, and never changed since they are hardcoded in (un)lexers
-
- BIND : Str = "&+" ;
- PARA : Str = "&-" ;
- CAPIT : Str = "&|" ;
-
---2 Miscellaneous
-
--- Identity function
-
- id : (A : Type) -> A -> A = \_,a -> a ;
-
--- Parentheses
-
- paren : Str -> Str = \s -> "(" ++ s ++ ")" ;
- parenss : SS -> SS = \s -> ss (paren s.s) ;
-
--- Zero, one, two, or more (elements in a list etc)
-
-param
- ENumber = E0 | E1 | E2 | Emore ;
-
-oper
- eNext : ENumber -> ENumber = \e -> case e of {
- E0 => E1 ; E1 => E2 ; _ => Emore} ;
-
-
-}
generated by cgit v1.2.3 (git 2.39.1) at 2026-05-20 17:39:23 +0000