def augParseCategory(line, primitives, families, var=None):
"""
Parse a string representing a category, and returns a tuple with
(possibly) the CCG variable for the category
"""
(cat_string, rest) = nextCategory(line)
if cat_string.startswith('('):
(res, var) = augParseCategory(cat_string[1:-1], primitives, families,
var)
else:
# print rePrim.match(str).groups()
(res, var) =\
parsePrimitiveCategory(PRIM_RE.match(cat_string).groups(), primitives,
families, var)
while rest != "":
app = APP_RE.match(rest).groups()
direction = parseApplication(app[0:3])
rest = app[3]
(cat_string, rest) = nextCategory(rest)
if cat_string.startswith('('):
(arg, var) = augParseCategory(cat_string[1:-1], primitives,
families, var)
else:
(arg, var) =\
parsePrimitiveCategory(PRIM_RE.match(cat_string).groups(),
primitives, families, var)
res = FunctionalCategory(res, arg, direction)
return (res, var)
def augParseCategory(line, primitives, families, var=None):
(str, rest) = nextCategory(line)
if str.startswith('('):
(res, var) = augParseCategory(str[1:-1], primitives, families, var)
else:
# print rePrim.match(str).groups()
(res, var) = parsePrimitiveCategory(
rePrim.match(str).groups(), primitives, families, var)
while rest != "":
app = reApp.match(rest).groups()
dir = parseApplication(app[0:3])
rest = app[3]
(str, rest) = nextCategory(rest)
if str.startswith('('):
(arg, var) = augParseCategory(str[1:-1], primitives, families, var)
else:
(arg, var) = parsePrimitiveCategory(
rePrim.match(str).groups(), primitives, families, var)
res = FunctionalCategory(res, arg, dir)
return (res, var)
def set_yield(category, new_yield):
if isinstance(category, PrimitiveCategory):
return new_yield
elif isinstance(category, FunctionalCategory):
return FunctionalCategory(set_yield(category.res(), new_yield),
category.arg(), category.dir())
else:
raise ValueError("unknown category type of instance %r" % category)
def combine(self, function, argument):
if not (function.is_function() and argument.is_function()):
return
if function.dir().can_compose() and argument.dir().can_compose():
subs = function.arg().can_unify(argument.res())
if not subs is None:
yield FunctionalCategory(function.res().substitute(subs),
argument.arg().substitute(subs),argument.dir())
def combine(self, left, right):
# Below implementation is specific for `index == 0`.
# Type-raise the argument at index 0.
raised_arg = FunctionalCategory(left.arg(), right, left.dir())
left = FunctionalCategory(left.res(), raised_arg, left.dir())
yield FunctionalCategory(left, right, left.dir())
def combine(self, function, argument):
if self.can_combine(function, argument):
categ = FunctionalCategory(
function.categ().res().res(), argument.categ().arg(), argument.categ().dir()
)
# TODO type-inference
fsem, asem = function.semantics(), argument.semantics()
new_arg = l.ApplicationExpression(asem, l.VariableExpression(fsem.variable)).simplify()
new_term = l.ApplicationExpression(fsem.term, new_arg).simplify()
semantics = l.LambdaExpression(fsem.variable, new_term)
yield categ, semantics
def combine(self, function, arg):
if not (function.categ().is_primitive() and arg.categ().is_function()
and arg.categ().res().is_function()):
return
# Type-raising matches only the innermost application.
arg = innermostFunction(arg.categ())
subs = function.categ().can_unify(arg.arg())
if subs is not None:
xcat = arg.res().substitute(subs)
categ = FunctionalCategory(
xcat, FunctionalCategory(xcat, function.categ(), arg.dir()),
-(arg.dir()))
# compute semantics
semantics = None
if function.semantics() is not None:
core = deepcopy(function.semantics())
parent = None
while isinstance(core, l.LambdaExpression):
parent = core
core = core.term
var = l.Variable("F")
while var in core.free():
var = l.unique_variable(pattern=var)
core = l.ApplicationExpression(
l.FunctionVariableExpression(var), core)
if parent is not None:
parent.term = core
else:
semantics = core
semantics = l.LambdaExpression(var, semantics)
yield categ, semantics
def traverse(node):
if node == search:
return [replace]
elif isinstance(node, FunctionalCategory):
left_subresults = [node.res()] + traverse(node.res())
right_subresults = [node.arg()] + traverse(node.arg())
results = [FunctionalCategory(left_subresult, right_subresult, node.dir())
for left_subresult, right_subresult
in itertools.product(left_subresults, right_subresults)
if not (left_subresult == node.res() and right_subresult == node.arg())]
return results
else:
return []
def combine(self, function, argument):
if not (function.categ().is_function() and argument.categ().is_function()):
return
if function.categ().dir().can_compose() and argument.categ().dir().can_compose():
subs = function.categ().arg().can_unify(argument.categ().res())
if subs is not None:
categ = FunctionalCategory(
function.categ().res().substitute(subs),
argument.categ().arg().substitute(subs),
argument.categ().dir())
fsem, asem = function.semantics(), argument.semantics()
if fsem is not None and asem is not None:
semantics = l.LambdaExpression(asem.variable, l.ApplicationExpression(fsem, asem.term).simplify())
else:
semantics = None
yield categ, semantics
def combine(self, function, argument):
if self.can_combine(function, argument):
yield FunctionalCategory(function.res().res(), argument.arg(),
argument.dir())