         
         let anchorToFollowFrame = frameForView(toFollowView, layouts: &layouts)
         let followerAnchorFrame = frameForView(followerView, layouts: &layouts)
-    
-        layouts[followerView] = followerAnchor.setValueForRect(anchorToFollow.valueForRect(anchorToFollowFrame), rect: followerAnchorFrame, inset: inset)
-    }
-    
-    init(anchorToFollow: T, followerAnchor: T, inset: CGFloat) {
+        
+        layouts[followerView] = followerAnchor.setValueForRect(anchorToFollow.valueForRect(anchorToFollowFrame), rect: followerAnchorFrame)
+    }
+    
+    init(anchorToFollow: T, followerAnchor: T) {
         self.anchorToFollow = anchorToFollow
         self.followerAnchor = followerAnchor
-        self.inset = inset
-    }
-    
-}
-
-public func Follow<T: Anchor>(anchor: T, withAnchor: T, inset: CGFloat) -> LayoutOperation {
-    return FollowOperation(anchorToFollow: anchor, followerAnchor: withAnchor, inset: inset)
-}
+    }
+    
+}
+
+// anchor.value + inset = withAnchor.value + inset
 
 public func Follow<T: Anchor>(anchor: T, withAnchor: T) -> LayoutOperation {
-    return Follow(anchor, withAnchor: withAnchor, inset: 0)
-}
-
+    return FollowOperation(anchorToFollow: anchor, followerAnchor: withAnchor)
+}
+

    return .FixIntention(view: view, value: value)
}

public func Fix(weight: CGFloat) -> PutIntention {
    return Fix(nil, weight)
}

public func Fix(view: UIView?) -> PutIntention {


public enum HAnchor : Anchor {
    
    case Left(UIView?, CGFloat)
    case Center(UIView?, CGFloat)
    case Right(UIView?, CGFloat)
    
    public func valueForRect(rect: CGRect) -> CGFloat {
        switch self {
        case .Left(_, let inset):
            return CGRectGetMinX(rect) + inset
        case .Right(_, let inset):
            return CGRectGetMaxX(rect) + inset
        case .Center(_, let inset):
            return CGRectGetMidX(rect) + inset
        }
    }
    
    public func setValueForRect(value: CGFloat, rect: CGRect) -> CGRect {
        var result = rect
        switch self {
        case .Left(_, let inset):
            result.origin.x = value - inset
        case .Right(_, let inset):
            result.origin.x = value - result.size.width - inset
        case .Center(_, let inset):
            result.origin.x = value - result.size.width/2 - inset
        }
        
        return result
