// @Note we might make these constructors their own
// classes if it's easier to think about making
// Words or Phrases. But I wanted to consolidate a bit.
// This constructor is a 'word' constructor.
// It makes a constant or a variable by itself.
public Expression(Atom head)
{
Type = head.Type;
Head = head;
Depth = 1;
// we check if the head expression has an atomic type.
// if it does, then we just initialize an empty array
// since this expression doesn't take any arguments.
if (Head.Type is AtomicType)
{
Args = new Argument[0];
NumArgs = 0;
return;
}
// we're going to populate the argument array with
// empty slots that are typed according to the
// semantic type of the functional head expression.
FunctionalType fType = head.Type as FunctionalType;
int fNumArgs = fType.GetNumArgs();
Args = new Argument[fNumArgs];
NumArgs = fNumArgs;
for (int i = 0; i < fNumArgs; i++)
{
Args[i] = new Empty(fType.GetInput(i));
}
}
public override int CompareTo(SemanticType other)
{
// any functional type is greater than any
// atomic type.
if (other is AtomicType)
{
return(1);
}
FunctionalType that = other as FunctionalType;
// if the arities of these semantic types are
// unequal, the higher arity is greater.
if (this.Input.Length > that.Input.Length)
{
return(1);
}
if (this.Input.Length < that.Input.Length)
{
return(-1);
}
for (int i = 0; i < Input.Length; i++)
{
int inputComparison = Input[i].CompareTo(that.Input[i]);
if (inputComparison < 0)
{
return(-1);
}
if (inputComparison > 0)
{
return(1);
}
}
var outputComparison = Output.CompareTo(that.Output);
if (outputComparison < 0)
{
return(-1);
}
if (outputComparison > 0)
{
return(1);
}
return(0);
}
public void SetFunctionalButton(FunctionalType type)
{
switch(type)
{
case FunctionalType.New:
_functionalButton.Text = "New";
_functionalButton.Image = Properties.Resources.ios7_plus_outline;
_functionalButton.Visible = true;
break;
case FunctionalType.Edit:
_functionalButton.Text = "Edit";
_functionalButton.Image = Properties.Resources.edit;
_functionalButton.Visible = true;
break;
case FunctionalType.Hide:
_functionalButton.Visible = false;
break;
}
flowLayoutPanel.AutoScrollPosition = new Point(flowLayoutPanel.HorizontalScroll.Maximum, 0);
}
public static SemanticType Push(SemanticType t, SemanticType ts)
{
if (ts is AtomicType)
{
return(new FunctionalType(new SemanticType[] { t }, (AtomicType)ts));
}
FunctionalType fts = ts as FunctionalType;
var numInputs = fts.GetNumArgs();
var newInputs = new SemanticType[numInputs + 1];
newInputs[0] = t;
for (int i = 0; i < numInputs; i++)
{
newInputs[i + 1] = fts.GetInput(i);
}
return(new FunctionalType(newInputs, fts.Output));
}
// if the input type is i1, ..., in -> o,
// and the lift type is l, then
// the geach type is (l -> i1), ..., (l -> in), l -> o
public static SemanticType Geach(SemanticType lift, SemanticType input)
{
if (input is AtomicType)
{
return(new FunctionalType(new SemanticType[] { lift }, (AtomicType)input));
}
FunctionalType ft = input as FunctionalType;
var numInputs = ft.GetNumArgs();
SemanticType[] newInputs = new SemanticType[numInputs + 1];
for (int i = 0; i < numInputs; i++)
{
newInputs[i] = Push(lift, ft.GetInput(i));
}
newInputs[numInputs] = lift;
return(new FunctionalType(newInputs, ft.Output));
}
public override bool Equals(Object o)
{
if (o.GetType() != typeof(FunctionalType))
{
return(false);
}
FunctionalType that = (FunctionalType)o;
if (Input.Length != that.GetNumArgs())
{
return(false);
}
for (int i = 0; i < Input.Length; i++)
{
if (Input[i] != that.GetInput(i))
{
return(false);
}
}
return(Output.Equals(that.Output));
}
