Skip to content
GitLab
Explore
Sign in
Primary navigation
Search or go to…
Project
I
inox
Manage
Activity
Members
Labels
Plan
Issues
Issue boards
Milestones
Wiki
Code
Merge requests
Repository
Branches
Commits
Tags
Repository graph
Compare revisions
Snippets
Build
Pipelines
Jobs
Pipeline schedules
Artifacts
Deploy
Releases
Package registry
Model registry
Operate
Environments
Terraform modules
Monitor
Incidents
Analyze
Value stream analytics
Contributor analytics
CI/CD analytics
Repository analytics
Model experiments
Help
Help
Support
GitLab documentation
Compare GitLab plans
Community forum
Contribute to GitLab
Provide feedback
Keyboard shortcuts
?
Snippets
Groups
Projects
Show more breadcrumbs
LARA
inox
Commits
afdf575f
Commit
afdf575f
authored
14 years ago
by
Ali Sinan Köksal
Browse files
Options
Downloads
Patches
Plain Diff
Two `parsing from printing' examples, performing quite bad.
parent
bfa4ad09
Branches
Branches containing commit
Tags
Tags containing commit
No related merge requests found
Changes
2
Hide whitespace changes
Inline
Side-by-side
Showing
2 changed files
cp-demo/ArithmeticExpressionParser.scala
+80
-0
80 additions, 0 deletions
cp-demo/ArithmeticExpressionParser.scala
cp-demo/PropositionalLogicParser.scala
+77
-0
77 additions, 0 deletions
cp-demo/PropositionalLogicParser.scala
with
157 additions
and
0 deletions
cp-demo/ArithmeticExpressionParser.scala
0 → 100644
+
80
−
0
View file @
afdf575f
import
cp.Definitions._
@spec
object
Specs
{
sealed
abstract
class
Token
case
class
IntLit
(
value
:
Int
)
extends
Token
case
class
Plus
()
extends
Token
case
class
Minus
()
extends
Token
case
class
Times
()
extends
Token
case
class
Div
()
extends
Token
case
class
LParen
()
extends
Token
case
class
RParen
()
extends
Token
sealed
abstract
class
TokenList
case
class
Cons
(
head
:
Token
,
tail
:
TokenList
)
extends
TokenList
case
class
Nil
()
extends
TokenList
def
size
(
l
:
TokenList
)
:
Int
=
(
l
match
{
case
Nil
()
=>
0
case
Cons
(
x
,
xs
)
=>
1
+
size
(
xs
)
})
ensuring
(
_
>=
0
)
def
append
(
l1
:
TokenList
,
l2
:
TokenList
)
:
TokenList
=
(
l1
match
{
case
Nil
()
=>
l2
case
Cons
(
t
,
ts
)
=>
Cons
(
t
,
append
(
ts
,
l2
))
})
ensuring
(
size
(
_
)
==
size
(
l1
)
+
size
(
l2
))
sealed
abstract
class
Tree
case
class
IntLitTree
(
value
:
Int
)
extends
Tree
case
class
PlusTree
(
left
:
Tree
,
right
:
Tree
)
extends
Tree
case
class
MinusTree
(
left
:
Tree
,
right
:
Tree
)
extends
Tree
case
class
TimesTree
(
left
:
Tree
,
right
:
Tree
)
extends
Tree
case
class
DivTree
(
left
:
Tree
,
right
:
Tree
)
extends
Tree
def
treeSize
(
t
:
Tree
)
:
Int
=
(
t
match
{
case
IntLitTree
(
_
)
=>
1
case
PlusTree
(
l
,
r
)
=>
1
+
treeSize
(
l
)
+
treeSize
(
r
)
case
MinusTree
(
l
,
r
)
=>
1
+
treeSize
(
l
)
+
treeSize
(
r
)
case
TimesTree
(
l
,
r
)
=>
1
+
treeSize
(
l
)
+
treeSize
(
r
)
case
DivTree
(
l
,
r
)
=>
1
+
treeSize
(
l
)
+
treeSize
(
r
)
})
ensuring
(
_
>=
0
)
def
valuesWithin
(
t
:
Tree
,
lower
:
Int
,
upper
:
Int
)
:
Boolean
=
t
match
{
case
IntLitTree
(
v
)
=>
lower
<=
v
&&
v
<=
upper
case
PlusTree
(
l
,
r
)
=>
valuesWithin
(
l
,
lower
,
upper
)
&&
valuesWithin
(
r
,
lower
,
upper
)
case
MinusTree
(
l
,
r
)
=>
valuesWithin
(
l
,
lower
,
upper
)
&&
valuesWithin
(
r
,
lower
,
upper
)
case
TimesTree
(
l
,
r
)
=>
valuesWithin
(
l
,
lower
,
upper
)
&&
valuesWithin
(
r
,
lower
,
upper
)
case
DivTree
(
l
,
r
)
=>
valuesWithin
(
l
,
lower
,
upper
)
&&
valuesWithin
(
r
,
lower
,
upper
)
}
def
enclose
(
l
:
TokenList
)
:
TokenList
=
append
(
Cons
(
LParen
(),
l
),
Cons
(
RParen
(),
Nil
()))
def
print
(
tree
:
Tree
)
:
TokenList
=
tree
match
{
case
IntLitTree
(
value
)
=>
Cons
(
IntLit
(
value
),
Nil
())
case
PlusTree
(
l
,
r
)
=>
append
(
print
(
l
),
Cons
(
Plus
(),
print
(
r
)))
case
MinusTree
(
l
,
r
)
=>
append
(
print
(
l
),
Cons
(
Minus
(),
print
(
r
)))
case
TimesTree
(
l
,
r
)
=>
append
(
print
(
l
),
Cons
(
Times
(),
print
(
r
)))
case
DivTree
(
l
,
r
)
=>
append
(
print
(
l
),
Cons
(
Div
(),
print
(
r
)))
}
def
printAlternative
(
tree
:
Tree
,
acc
:
TokenList
)
:
TokenList
=
tree
match
{
case
IntLitTree
(
value
)
=>
Cons
(
IntLit
(
value
),
acc
)
case
PlusTree
(
l
,
r
)
=>
printAlternative
(
l
,
Cons
(
Plus
(),
printAlternative
(
r
,
acc
)))
case
MinusTree
(
l
,
r
)
=>
printAlternative
(
l
,
Cons
(
Minus
(),
printAlternative
(
r
,
acc
)))
case
TimesTree
(
l
,
r
)
=>
printAlternative
(
l
,
Cons
(
Times
(),
printAlternative
(
r
,
acc
)))
case
DivTree
(
l
,
r
)
=>
printAlternative
(
l
,
Cons
(
Div
(),
printAlternative
(
r
,
acc
)))
}
}
object
ArithmeticExpressionParser
{
import
Specs._
def
main
(
args
:
Array
[
String
])
:
Unit
=
{
val
tokens
=
Cons
(
IntLit
(
0
),
Cons
(
Plus
(),
Cons
(
IntLit
(
0
),
Nil
())))
val
tree
=
((
t
:
Tree
)
=>
valuesWithin
(
t
,
0
,
0
)
&&
print
(
t
)
==
tokens
).
solve
println
(
"The tree I found: "
+
tree
)
println
(
"Printing : "
+
print
(
tree
))
}
}
This diff is collapsed.
Click to expand it.
cp-demo/PropositionalLogicParser.scala
0 → 100644
+
77
−
0
View file @
afdf575f
import
cp.Definitions._
@spec
object
Specs
{
sealed
abstract
class
Bool
case
class
True
()
extends
Bool
case
class
False
()
extends
Bool
sealed
abstract
class
Token
case
class
BooleanLit
(
value
:
Bool
)
extends
Token
case
class
And
()
extends
Token
case
class
Or
()
extends
Token
case
class
Implies
()
extends
Token
case
class
LParen
()
extends
Token
case
class
RParen
()
extends
Token
sealed
abstract
class
TokenList
case
class
Cons
(
head
:
Token
,
tail
:
TokenList
)
extends
TokenList
case
class
Nil
()
extends
TokenList
def
size
(
l
:
TokenList
)
:
Int
=
(
l
match
{
case
Nil
()
=>
0
case
Cons
(
x
,
xs
)
=>
1
+
size
(
xs
)
})
ensuring
(
_
>=
0
)
def
append
(
l1
:
TokenList
,
l2
:
TokenList
)
:
TokenList
=
(
l1
match
{
case
Nil
()
=>
l2
case
Cons
(
t
,
ts
)
=>
Cons
(
t
,
append
(
ts
,
l2
))
})
ensuring
(
size
(
_
)
==
size
(
l1
)
+
size
(
l2
))
sealed
abstract
class
Tree
case
class
BooleanLitTree
(
value
:
Bool
)
extends
Tree
case
class
AndTree
(
left
:
Tree
,
right
:
Tree
)
extends
Tree
case
class
OrTree
(
left
:
Tree
,
right
:
Tree
)
extends
Tree
case
class
ImpliesTree
(
left
:
Tree
,
right
:
Tree
)
extends
Tree
def
treeSize
(
t
:
Tree
)
:
Int
=
(
t
match
{
case
BooleanLitTree
(
_
)
=>
1
case
AndTree
(
l
,
r
)
=>
1
+
treeSize
(
l
)
+
treeSize
(
r
)
case
OrTree
(
l
,
r
)
=>
1
+
treeSize
(
l
)
+
treeSize
(
r
)
case
ImpliesTree
(
l
,
r
)
=>
1
+
treeSize
(
l
)
+
treeSize
(
r
)
})
ensuring
(
_
>=
0
)
def
enclose
(
l
:
TokenList
)
:
TokenList
=
append
(
Cons
(
LParen
(),
l
),
Cons
(
RParen
(),
Nil
()))
def
print
(
tree
:
Tree
)
:
TokenList
=
tree
match
{
case
BooleanLitTree
(
value
)
=>
Cons
(
BooleanLit
(
value
),
Nil
())
case
AndTree
(
l
,
r
)
=>
append
(
print
(
l
),
Cons
(
And
(),
print
(
r
)))
case
OrTree
(
l
,
r
)
=>
append
(
print
(
l
),
Cons
(
Or
(),
print
(
r
)))
case
ImpliesTree
(
l
,
r
)
=>
append
(
print
(
l
),
Cons
(
Implies
(),
print
(
r
)))
}
def
printAlternative
(
tree
:
Tree
,
acc
:
TokenList
)
:
TokenList
=
tree
match
{
case
BooleanLitTree
(
value
)
=>
Cons
(
BooleanLit
(
value
),
acc
)
case
AndTree
(
l
,
r
)
=>
printAlternative
(
l
,
Cons
(
And
(),
printAlternative
(
r
,
acc
)))
case
OrTree
(
l
,
r
)
=>
printAlternative
(
l
,
Cons
(
Or
(),
printAlternative
(
r
,
acc
)))
case
ImpliesTree
(
l
,
r
)
=>
printAlternative
(
l
,
Cons
(
Implies
(),
printAlternative
(
r
,
acc
)))
}
}
object
PropositionalLogicParser
{
import
Specs._
implicit
def
scalaList2list
(
l
:
List
[
Token
])
:
TokenList
=
l
match
{
case
scala
.
collection
.
immutable
.
Nil
=>
Nil
()
case
t
::
ts
=>
Cons
(
t
,
scalaList2list
(
ts
))
}
def
main
(
args
:
Array
[
String
])
:
Unit
=
{
// val tokens : TokenList = List[Token](BooleanLit(False()), And(), BooleanLit(True()), And(), BooleanLit(True()))
val
tokens
:
TokenList
=
List
[
Token
](
BooleanLit
(
False
()),
Or
(),
BooleanLit
(
True
()))
val
tree
=
((
t
:
Tree
)
=>
print
(
t
)
==
tokens
).
solve
println
(
"The tree I found: "
+
tree
)
println
(
"Printing : "
+
print
(
tree
))
}
}
This diff is collapsed.
Click to expand it.
Preview
0%
Loading
Try again
or
attach a new file
.
Cancel
You are about to add
0
people
to the discussion. Proceed with caution.
Finish editing this message first!
Save comment
Cancel
Please
register
or
sign in
to comment