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())