Swift color util for cool friends

FColor.swift

import UIKit

public class FColor{
    
    public var a:CGFloat = 1.0;
    public var r:CGFloat = 1.0;
    public var g:CGFloat = 1.0;
    public var b:CGFloat = 1.0;
    init(r:CGFloat = 1.0, g:CGFloat = 1.0, b:CGFloat = 1.0, a:CGFloat = 1.0){
        self.r = r;
        self.g = g;
        self.b = b;
        self.a = a;
    }
    
    public func set(red:CGFloat, green:CGFloat, blue:CGFloat, alpha:CGFloat) -> FColor{
        r = red;
        g = green;
        b = blue;
        a = alpha;
        return self;
    }
    
    public func alpha(value:CGFloat) -> FColor{
        a = value;
        return self;
    }
    public func red(value:CGFloat) -> FColor{
        r = value;
        return self;
    }
    public func green(value:CGFloat) -> FColor{
        g = value;
        return self;
    }
    public func blue(value:CGFloat) -> FColor{
        b = value;
        return self;
    }
    
    //Lerp this color into another
    
    public func mix(other:FColor, ratio:CGFloat) -> FColor{
        a = a+(other.a-a)*ratio;
        r = r+(other.r-r)*ratio;
        g = g+(other.g-g)*ratio;
        b = b+(other.b-b)*ratio;
        return self;
    }
    
    //Copyfun
    
    public func clone() -> FColor{
        return FColor(a:a,r:r,g:g,b:b);
    }
    
    public func copyFrom(other:FColor)->FColor{
        a = other.a;
        r = other.r;
        g = other.g;
        b = other.b;
        return self;
    }
    
    public func fromHex24(color:UInt32) -> FColor{
        a = CGFloat( Float( (color>>24) ) / 255.0 );
        r = CGFloat( Float( (color>>16 & 0xFF) ) / 255.0 );
        g = CGFloat( Float( (color>>8 & 0xFF) ) / 255.0 );
        b = CGFloat( Float( (color & 0xFF) ) / 255.0 );
        return self;
    }
    
    public func fromHex16(color:UInt32, alpha:CGFloat = 1.0) -> FColor{
        a = alpha;
        r = CGFloat( Float( (color>>16 & 0xFF) ) / 255.0 );
        g = CGFloat( Float( (color>>8 & 0xFF) ) / 255.0 );
        b = CGFloat( Float( (color & 0xFF) ) / 255.0 );
        return self;
    }
    
    //Boring-ass endpoint because UIColor blows and Swift doesn't have cast functions
    
    public func toUIColor()->UIColor{
        return UIColor(red:r, green:g, blue:b, alpha:a);
    }
    
    
    //Statics

    
    //Factories
    
    public class func mix(a:FColor, b:FColor, ratio:CGFloat) -> FColor{
        var c = a.clone();
        c.a = a.a+(b.a-a.a)*ratio;
        c.r = a.r+(b.r-a.r)*ratio;
        c.g = a.g+(b.g-a.g)*ratio;
        c.b = a.b+(b.b-a.b)*ratio;
        return c;
    }
    
    public class func fromHex24(color:UInt32) -> FColor{
        return FColor().fromHex24(color);
    }
    public class func fromHex16(color:UInt32, alpha:CGFloat = 1.0) -> FColor{
        return FColor().fromHex16(color, alpha: alpha);
    }
    
    public class func white(alpha:CGFloat = 1.0) -> FColor{
        return FColor(a:alpha);
    }
    
    public class func black(alpha:CGFloat = 1.0) -> FColor{
        return FColor(r:0.0, g:0.0, b:0.0, a:alpha);
    }
    
    public class func gray(alpha:CGFloat = 1.0) -> FColor{
        var value:CGFloat = 0.5;
        return FColor(r:value, g:value, b:value, a:alpha);
    }
    
    public class func darkGray(alpha:CGFloat = 1.0) -> FColor{
        var value:CGFloat = 1/3;
        return FColor(r:value, g:value, b:value, a:alpha);
    }
    
    public class func lightGray(alpha:CGFloat = 1.0) -> FColor{
        var value:CGFloat = 2/3;
        return FColor(r:value, g:value, b:value, a:alpha);
    }
    
    public class func red(alpha:CGFloat = 1.0) -> FColor{
        return FColor(r:1.0, g:0.0, b:0.0, a:alpha);
    }
    
    public class func green(alpha:CGFloat = 1.0) -> FColor{
        return FColor(r:0.0, g:1.0, b:0.0, a:alpha);
    }
    
    public class func blue(alpha:CGFloat = 1.0) -> FColor{
        return FColor(r:0.0, g:0.0, b:1.0, a:alpha);
    }
    
    public class func cyan(alpha:CGFloat = 1.0) -> FColor{
        return FColor(r:0.0, g:1.0, b:1.0, a:alpha);
    }
    
    public class func yellow(alpha:CGFloat = 1.0) -> FColor{
        return FColor(r:1.0, g:1.0, b:0.0, a:alpha);
    }
    
    public class func magenta(alpha:CGFloat = 1.0) -> FColor{
        return FColor(r:1.0, g:0.0, b:1.0, a:alpha);
    }

    public class func orange(alpha:CGFloat = 1.0) -> FColor{
        return FColor(r:1.0, g:0.5, b:0.0, a:alpha);
    }
    
    public class func purple(alpha:CGFloat = 1.0) -> FColor{
        return FColor(r:0.5, g:0.0, b:0.5, a:alpha);
    }
    
    public class func brown(alpha:CGFloat = 1.0) -> FColor{
        return FColor(r:0.6, g:0.4, b:0.2, a:alpha);
    }
    
    public class func clear() -> FColor{
        return FColor(r:0.0, g:0.0, b:0.0, a:0.0);
    }
    
}

//random chained stuff blending a 16 bit hex color with some other shit
var c = FColor.mix(
    FColor.fromHex16(0xFF0000),
    b: FColor.cyan(alpha: 0.5), //Super weird, why is b necessary but a "extraneous"?
    ratio:0.5 );

var col = c.toUIColor(); //... a uicolor you can use.