text:
Make a long type signature
Challenge
Find an expression, at most 100 bytes long, with the longest type signature.
Rules

Any statically typed language with type inference is allowed
The type must be non-ambiguous, but otherwise may include types without defined instances. For example Num [a] and Eq [a] are allowed, even without a defined instance
No imports other than the minimum required to compile a program with STDIN/STDOUT
Infinite types are not allowed
If an answer has more than one expression, only one may contribute to the score. For example, although the type signature of composition is (.) :: (b -> c) -> (a -> b) -> a -> c, having a score of 20, the answer with 25 copies of (.)\n would have a score of 20, not 500
The expression must be, at most, 100 bytes
The score is the number of characters in the type signature, excluding the name of the function and any whitespace. For example, f :: (a -> b) -> a -> b would have a score of 12
The highest score wins!

Examples
Although other languages are allowed, the following examples are in Haskell:
Score: 112
map.map.map.map.map.map.map.map.map.map.map.map.map.map.map.map.map.map.map.map.map.map.map.map.map
f :: (a -> b)
 -> [[[[[[[[[[[[[[[[[[[[[[[[[a]]]]]]]]]]]]]]]]]]]]]]]]]
 -> [[[[[[[[[[[[[[[[[[[[[[[[[b]]]]]]]]]]]]]]]]]]]]]]]]]

Score: 240
(.).(.).(.).(.).(.).(.).(.).(.).(.).(.).(.).(.).(.).(.).(.).(.).(.).(.).(.).(.).(.).(.).(.).(.).(.)
f :: (b->c)->(a->a1->a2->a3->a4->a5->a6->a7->a8->a9->a10->a11->a12->a13->a14->a15->a16->a17->a18->a19->a20->a21->a22->a23->a24->b)->a1->a2->a3->a4->a5->a6->a7->a8->a9->a10->a11->a12->a13->a14->a15->a16->a17->a18->a19->a20->a21->a22->a23->a24->c

Score: 313
foldl$foldl$foldl$foldl$foldl$foldl$foldl$foldl$foldl$foldl$foldl$foldl$foldl$foldl$foldl$foldl(.)
f :: (Foldable t, Foldable t1, Foldable t2, Foldable t3, Foldable t4,
  Foldable t5, Foldable t6, Foldable t7, Foldable t8, Foldable t9,
  Foldable t10, Foldable t11, Foldable t12, Foldable t13,
  Foldable t14, Foldable t15) =>
 (b -> c)
 -> t (t1 (t2 (t3 (t4 (t5 (t6 (t7 (t8 (t9 (t10 (t11 (t12 (t13 (t14 (t15 (b
 -> b))))))))))))))))
 -> b
 -> c

Score: 538
lex.show.foldl1.mapM.traverse.sum.mapM.sum.traverse.(.).mapM.scanl.zipWith3((.traverse).(.traverse))
 (Num
    (a -> ([[c]] -> t3 [[a1 -> f b]]) -> [[c]] -> t3 [[a1 -> f b]]),
  Num
    (([[c]] -> t3 [[a1 -> f b]])
     -> t1 (t2 ([[c]] -> t3 [[a1 -> f b]]))
     -> [[c]]
     -> t3 [[a1 -> f b]]),
  Show
    (t (t1 (t2 ([[c]] -> t3 [[a1 -> f b]])))
     -> t1 (t2 ([[c]] -> t3 [[a1 -> f b]]))),
  Applicative f, Foldable t,
  Foldable ((->) (t1 (t2 ([[c]] -> t3 [[a1 -> f b]])) -> a)),
  Foldable
    ((->) (([[c]] -> t3 [[a1 -> f b]]) -> a -> t3 [a1 -> f b])),
  Traversable t1, Traversable t2, Traversable t3, Traversable t4,
  Traversable t5,
  Traversable ((->) (t1 (t2 ([[c]] -> t3 [[a1 -> f b]])))),
  Traversable ((->) ([[c]] -> t3 [[a1 -> f b]]))) =>
 [(t5 (t4 a1) -> f (t5 (t4 b))) -> c -> a1 -> f b]
 -> [(String, String)]

Related. I did think there was an almost exact dupe, but I haven't found it.

I suspect that a language with dependent typing can make a type signature of the length of any number of can compute.

@xnor As type systems themselves may be turing complete (http://stackoverflow.com/a/4047732/5154287), I guess it becomes more of a busy beaver problem then. Should I edit the tags?

Haskell, ~2^(2^18)
f x=(x,x)
g=f.f.f.f
h=g.g.g.g
i=h.h.h.h
j=i.i.i.i
k=j.j.j.j
l=k.k.k.k
m=l.l.l.l
n=m.m.m.m
n.n.n.n$0

Each application of f roughly double the type signature by transforming the type signature T to (T,T). For example, the fourfold composition f.f.f.f$0 has type
Num a => ((((a, a), (a, a)), ((a, a), (a, a))), (((a, a), (a, a)), ((a, a), (a, a))))

Each line quadraples the number of applications of f, giving 4^9 = 2^18 at the end. So, the type signature has size of the order of 2^(2^18).

The classic approach, but I think the parameters can be better tuned. Specifically, I think that f x=(x,x,x) at the cost of one n. in the last line gives the optimal score for this overall structure.

I don't know Haskell, so I could be off base here, but I'll point out that 4^(4^4) is less than 3^(4^5)

Pretty sure the 4th n. is going to be larger. 2^18 vs 3 * (2^16) unless I made a mistake calculating the original exponentiation: 2^(4^9) vs. 3^((4^8)*3)

No, @PeterTaylor is correct: 2^(4^9) = 16^(4^8) < 27^(4^8) = 3^(4^8 ⋅ 3).

(,) (or (,,)) can be used to save some bytes and improve the score by using more ns.

@BWO I don’t see how: since (,) :: a -> b -> (a, b) has two type variables repeated twice rather than one type variable repeated thrice, the type of (,).(,).(,).(,) :: a -> b1 -> (b2 -> (b3 -> (b4 -> (a, b4), b3), b2), b1) only grows as $O(n \log_{10} n)$ with the number of (,)s instead of exponentially. You can write xnor’s f as id=<<(,) but that’s longer. You can use (:), leading to the answer I posted the day before your comment.

Haskell with extensions, \$\ggg A(A(A(A(220,0),0),0),0)\$
Z::Z#Z#Z#Z#Z#Z#Z#Z#Z?Z
data a?b=Z|S(a?b)
type family m#n where Z#n=S n;S m#Z=m#S m;S m#S n=m#(S m#n)

Try it online!
Requires -XDataKinds, -XPolyKinds, -XTypeOperators, -XUndecidableInstances, and -XTypeFamilies.
Many thanks to Ørjan Johansen, who realized that making the natural number constructor infix and building the arguments a bit differently saved two bytes, making just enough room for another iteration of #.
Obviously, the type checker will give up trying to check this program. To get a general sense of what the signature would look like (if it were small enough to fit in the observable universe), try the much smaller
Z::S(S Z)#Z?Z

Explanation
The # type family is closely related the Ackermann–Péter function, commonly written \$A\$, but # grows faster. The Ackermann–Péter function is defined

\$A(0,n)=n+1\$
\$A(m,0)=A(m-1,1)\$ when \$m > 0\$
\$A(m,n)=A(m-1, A(m, n-1))\$ when \$ m, n > 0 \$

#, on the other hand, we can call \$B\$, and write

\$B(0,n)=n+1\$
\$B(m,0)=B(m-1,m)\$ when \$m > 0\$
\$B(m,n)=B(m-1, B(m, n-1))\$ when \$m,n > 0\$

Only the second case is different. The termination proof is identical to the standard one for \$A\$, and it should be clear that \$B(m,n) \ge A(m,n)\$ for all \$m\$ and \$n\$.
Here we calculate a unary representation of

\$r = B(B(B(B(B(B(B(B(0,0),0),0),0),0),0),0),0) \$

By direct calculation, \$B(B(B(B(0,0),0),0),0)=220\$, so

\$r = B(B(B(B(220,0),0),0),0)\$.

Note that \$A(A(A(A(0,0),0),0),0)\$ is only \$5\$, so we've bumped things up a good bit to start out. I don't have a very clear sense of just how much faster \$B\$ grows than \$A\$, but considering how the calculation proceeds, it seems likely to grow quite a lot faster.
The number of digits in even \$A(6,0)\$ is too large to express practically in decimal, so this is ... rather ridiculously large.
The definition of the natural numbers, (?), is a bit non-standard. To save space, we use (?) as both a natural number type (at the type level) and a proxy type (at the term level).
I believe that either TypeFamilies or (more verbosely and obfuscatedly) FunctionalDependencies are necessary to get the type-level computation required to reach truly large types. UndecidableInstances is needed to work around Haskell's very primitive termination checking. The other extensions are only needed to compress the code into the small available space.

One more #Z

@ØrjanJohansen, is stacking up Zs at the front better than starting with S(S Z)#S Z, or the same?

Either way, the extra #Z at the end is most welcome.

It's the exact same value but saves one byte, and changing the datatype to ? saves the other, leaving room for the extra #Z.

While you were first editing, I discovered A(m,1) was never bigger than A(A(m,0),0), and was about to remark on it, but then you'd just optimized to the point where the options were equal. (Also m+1 is never bigger than A(m,0).)

@ØrjanJohansen, I've made a fairly substantial improvement; I'd really appreciate if you could double check that I haven't goofed up the calculation somewhere.

Looks good, although if we're tweaking the function, I think this gets out of the ballpark faster - Z#Z#Z#Z is already humongous, which makes up for the one byte longer type family.

My intuition btw is that all of these functions are "about the same size" for each m plus or minus 1, once you get into the incomprehensibly large territory, so it's all about getting there as fast as possible and then have room to heap on more #Zs.

@ØrjanJohansen, the switch from A to B was a no-brainer, because it has the same number of bytes. As for how they compare ... my intuition isn't great. Certainly, though, getting a fast start is very helpful for obtaining results whose size is easy to bound (below) by well-known functions like A. Thanks for the improvement; I actually considered the S(S n) change alone before I realized there was free Indian buffet lunch to be had.

Java, score 17301488
Requires the method <T>java.util.Map<T,T>f(T t){return null;}, which has been counted towards the 100-byte limit.
f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(1)))))))))))))))))))
The compile-time type signature of this should match this.

hmm. since lambdas are allowed this would probably get a higher score

Haskell, 9·2663552 − 3 (≈ 1.02·10199750)
A small (“small”) improvement over xnor’s 5⋅2262144 + 5.  This is 99 bytes.
f=(:).(:)
g=f.f.f.f
h=g.g.g.g
i=h.h.h.h
j=i.i.i.i
k=j.j.j.j
l=k.k.k.k
m=l.l.l
n=m.m.m
o=n.n.n
o.o.o

How it works
We have
(:)         :: a -> [a] -> [a]
(:).(:)     :: a -> [[a] -> [a]] -> [[a] -> [a]]
(:).(:).(:) :: a -> [[[a] -> [a]] -> [[a] -> [a]]] -> [[[a] -> [a]] -> [[a] -> [a]]]

and so on, with the length roughly doubling for each (:). The given expression o.o.o works out to (:).(:).(:).….(:) with 2·46·34 = 663552 copies of (:).
Haskell with FlexibleContexts and NoMonomorphismRestriction, (200·4331776 + 75·331776 + 16)/9 ≈ 2.53·10199750
A small improvement over Bubbler’s 12·2663552 + 9·663552 − 4 ≈ 1.36·10199750, which also relies on these extensions.  The wording of the challenge sort of suggests it might be okay to rely on them (“For example Num [a] and Eq [a] are allowed, even without a defined instance”); I’m not sure.  This is 100 bytes.
f=(/).(:)
g=f.f.f.f
h=g.g.g.g
i=h.h.h.h
j=i.i.i.i
k=j.j.j.j
l=k.k.k.k
m=l.l.l
n=m.m.m
o=n.n.n
-o.o.o

How it works
We have
-(/).(:) :: (Fractional ([a] -> [a]), Num (a -> ([a] -> [a]) -> [a] -> [a])) => a -> ([a] -> [a]) -> [a] -> [a]
-(/).(:).(/).(:) :: (Fractional ([a] -> [a]), Fractional ([([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]), Num (a -> ([([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]) -> [([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]])) => a -> ([([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]) -> [([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]
-(/).(:).(/).(:).(/).(:) :: (Fractional ([a] -> [a]), Fractional ([([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]), Fractional ([([([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]) -> [([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]] -> [([([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]) -> [([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]]), Num (a -> ([([([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]) -> [([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]] -> [([([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]) -> [([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]]) -> [([([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]) -> [([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]] -> [([([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]) -> [([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]])) => a -> ([([([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]) -> [([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]] -> [([([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]) -> [([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]]) -> [([([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]) -> [([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]] -> [([([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]) -> [([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]]

and so on, with the length roughly quadrupling for each (/).(:). The given expression -o.o.o works out to -(/).(:).(/).(:).….(/).(:) with 46·34 = 331776 copies of (/).(:).

Haskell, 12·2663552 + 9·663552 - 4
Yet another small improvement over Anders Kaseorg's answer.
f=(/).(/)
g=f.f.f.f
h=g.g.g.g
i=h.h.h.h
j=i.i.i.i
k=j.j.j.j
l=k.k.k.k
m=l.l.l
n=m.m.m
o=n.n.n
o.o.o

How it works
(/) -- score 27
   :: Fractional a => a -> a -> a
(/).(/) -- score 62
   :: (Fractional a, Fractional (a -> a)) => a -> (a -> a) -> a -> a
(/).(/).(/) -- score 119
   :: (Fractional a, Fractional (a -> a), Fractional ((a -> a) -> a -> a)) =>
      a -> ((a -> a) -> a -> a) -> (a -> a) -> a -> a
(/).(/).(/).(/) -- score 224
   :: (Fractional a, Fractional (a -> a),
       Fractional ((a -> a) -> a -> a),
       Fractional (((a -> a) -> a -> a) -> (a -> a) -> a -> a)) =>
      a
      -> (((a -> a) -> a -> a) -> (a -> a) -> a -> a)
      -> ((a -> a) -> a -> a)
      -> (a -> a)
      -> a
      -> a

Just changed function composition (.) to fractional division (/). The Fractional x part in the function signature explodes along with the main part, giving slightly higher constant multiplier.

C, 979
#define a int,int,int
#define b a,a,a,a
#define c b,b,b
#define d c,c,c
#define e d,d,d
int(*f)(e);

f has the signature:
int(*)(int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int)

979 33554438 58640620148060 this looks like some ridiculous OEIS entry. possibly the largest changes in magnitude I've ever seen in a PPCG entry being refined.

@Sparr you ain't seen nuthin' yet

Idris, >hyper(hyper(hyper(hyper(999999999, 99, 99), 99,99),99,99),99,99)
f:Nat->Type
f Z=()
f(S n)=hyper n n n~=~f n
the$f$hyper(hyper(hyper(hyper 999999999 9 9) 9 9)9 9)9 9

Explanation:
We're defining a function f, computing a type f(0) is just the unit type, while f(S(n)) computes to the equality type applied to the function argument "hypered" by itself and to f applied to n. The last line basically is a function expecting a value of a type like (27 = (4 = (2 = (1 = ()))))) (for n=4).
Simple Example
f 3 = (27 = (4 = (2 = (1 = ()))))

I don't really know Idris, but I think this may fail on a technicality: You're supposed to maximize the length of the type signature of an expression, not the length of its value. Isn't the type signature of your final expression just :Type?

What do you mean by an uncomputable number? I'm not familiar with hyper; could you explain?

@ØrjanJohansen Oh yes, just fixed that and applied a few more changes

@dfeuer uncomputable only in the way such that the process would take until the end of the universe.

(0) Explanation seems lagging a bit. (1) This is just 98 bytes now. (2) Since the first argument of hyper gets amplified enormously more than the rest, I think you want all/most of those 99s to be 9s. (3) Assuming Idris's $ works like Haskell's, the outer set of parentheses after f$ is redundant. (4) Could you abbreviate hyper or would that require a type signature itself?

And what is hyper?

@dfeuer https://en.wikipedia.org/wiki/Hyperoperation (The Idris definition is a direct translation.)

@ØrjanJohansen (1,2,3) fixed, (4) would require a type signature since implicit arguments determined by the type signature are a thing in idris

Hm, for the same reason as (2), I suspect you'll get a huger type by dropping f and just putting something like ~=~() at the end of the final expression.

@ØrjanJohansen probably, but it wouldn't be as fun xD

C#, 363
Expression:
new{a=new{a=new{a=new{a=new{a=new{a=new{a=new{a=new{a=new{a=new{a=new{a=new{a=new{a=""}}}}}}}}}}}}}}

Type signature:
<>f__AnonymousType0#1`1[<>f__AnonymousType0#1`1[<>f__AnonymousType0#1`1[<>f__AnonymousType0#1`1[<>f__AnonymousType0#1`1[<>f__AnonymousType0#1`1[<>f__AnonymousType0#1`1[<>f__AnonymousType0#1`1[<>f__AnonymousType0#1`1[<>f__AnonymousType0#1`1[<>f__AnonymousType0#1`1[<>f__AnonymousType0#1`1[<>f__AnonymousType0#1`1[<>f__AnonymousType0#1`1[System.String]]]]]]]]]]]]]]

Try it online!

Go 1.0 without reflect, 98
Go 1.x types are statically defined. Here is my first try:
[][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]string{}

On the Go playground:
package main;import "fmt"
func main() {

    x := [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]string{}

    fmt.Printf("%d %T\n", len(fmt.Sprintf("%T", x)), x)
}

Go 1.9 using type aliases, 2389
type(I=interface{f();g()};S=struct{p,q,r,s,t,u,v,w,x,y,z I});map[S]map[S]map[S]map[S]map[S]map[S]S{}

On the Go playground:
package main;import("fmt";"strings")
func main() {

    type(I=interface{f();g()};S=struct{p,q,r,s,t,u,v,w,x,y,z I});x:=map[S]map[S]map[S]map[S]map[S]map[S]S{}

    fmt.Printf("%d %T\n", len(strings.Replace(fmt.Sprintf("%T", x), " ", "", -1)), x)
}

Result:
2389 map[struct { p interface { main.f(); main.g() }; q interface { main.f(); main.g() }; r interface { main.f(); main.g() }; s interface { main.f(); main.g() }; t interface { main.f(); main.g() }; u interface { main.f(); main.g() }; v interface { main.f(); main.g() }; w interface { main.f(); main.g() }; x interface { main.f(); main.g() }; y interface { main.f(); main.g() }; z interface { main.f(); main.g() } }]map[struct { p interface { main.f(); main.g() }; q interface { main.f(); main.g() }; r interface { main.f(); main.g() }; s interface { main.f(); main.g() }; t interface { main.f(); main.g() }; u interface { main.f(); main.g() }; v interface { main.f(); main.g() }; w interface { main.f(); main.g() }; x interface { main.f(); main.g() }; y interface { main.f(); main.g() }; z interface { main.f(); main.g() } }]map[struct { p interface { main.f(); main.g() }; q interface { main.f(); main.g() }; r interface { main.f(); main.g() }; s interface { main.f(); main.g() }; t interface { main.f(); main.g() }; u interface { main.f(); main.g() }; v interface { main.f(); main.g() }; w interface { main.f(); main.g() }; x interface { main.f(); main.g() }; y interface { main.f(); main.g() }; z interface { main.f(); main.g() } }]map[struct { p interface { main.f(); main.g() }; q interface { main.f(); main.g() }; r interface { main.f(); main.g() }; s interface { main.f(); main.g() }; t interface { main.f(); main.g() }; u interface { main.f(); main.g() }; v interface { main.f(); main.g() }; w interface { main.f(); main.g() }; x interface { main.f(); main.g() }; y interface { main.f(); main.g() }; z interface { main.f(); main.g() } }]map[struct { p interface { main.f(); main.g() }; q interface { main.f(); main.g() }; r interface { main.f(); main.g() }; s interface { main.f(); main.g() }; t interface { main.f(); main.g() }; u interface { main.f(); main.g() }; v interface { main.f(); main.g() }; w interface { main.f(); main.g() }; x interface { main.f(); main.g() }; y interface { main.f(); main.g() }; z interface { main.f(); main.g() } }]map[struct { p interface { main.f(); main.g() }; q interface { main.f(); main.g() }; r interface { main.f(); main.g() }; s interface { main.f(); main.g() }; t interface { main.f(); main.g() }; u interface { main.f(); main.g() }; v interface { main.f(); main.g() }; w interface { main.f(); main.g() }; x interface { main.f(); main.g() }; y interface { main.f(); main.g() }; z interface { main.f(); main.g() } }]struct { p interface { main.f(); main.g() }; q interface { main.f(); main.g() }; r interface { main.f(); main.g() }; s interface { main.f(); main.g() }; t interface { main.f(); main.g() }; u interface { main.f(); main.g() }; v interface { main.f(); main.g() }; w interface { main.f(); main.g() }; x interface { main.f(); main.g() }; y interface { main.f(); main.g() }; z interface { main.f(); main.g() } }

Go 1 using reflect, 65532
There is a limit in package reflect on the length of type names: len(name) <= 1<<16-1
I've been able to reach a type name of 65532 bytes so far with this block:
t:=reflect.TypeOf(0);u:=t;for i:=0;i<8191;i++{t=reflect.MapOf(u,t)};reflect.New(t).Interface()

Full code on the Go playground:
package main;import("fmt";"reflect")
func main() {

    t:=reflect.TypeOf(0);u:=t;for i:=0;i<8191;i++{t=reflect.MapOf(u,t)};x:=reflect.New(t).Interface()

    fmt.Printf("%d %T\n", len(fmt.Sprintf("%T", x)), x)
}

Notes: x:= is never counted.

invalid, reflect import would need to be counted

3403?

3685

65535

C#, 100 bytes, score = \$3.7996944224×10^{21}\$
class X<A,B,C,D,E,F,G>{class Y:X<Y,Y,Y,Y,Y,Y,Y>{Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y.Y y;}}

Solution inspired by this answer.
There are two variables that contribute to the length of the type signature of the variable y: the number of generic type arguments on X and the number of nested class accesses in Y.
The following formula represents the length of the generated type signature not counting whitespace:
\$ L\ =\ \frac{x^{y}\cdot((x-1)(2x^{2}+5x+4)+x+4)-(x+4)}{(x-1)} \$
where x is the number of generic type arguments on X (e.g. for X<A,B,C,D>, x = 4) and y is the number of .Ys
Using Desmos and trial and error, I found the maximum length value where x and y would fit in 100 bytes was at x=7 y=23.
Try it online!

Rust, 99 bytes, score=46,137,336
fn b<T>(a:T)->Result<T,T>{Ok(a)}b(b(b(b(b(b(b(b(b(b(b(b(b(b(b(b(b(b(b(b(b(b(0))))))))))))))))))))))

Attempt This Online!

Rust, 100 bytes, Score \$\approx 2.22128\times 10^{78}\$
The score is \$8+\underbrace{6\times(6\times(\cdots(6\times2+7)\cdots)+7)+7}_{100 \text{ levels}}=\$ 2221283319900241080728746908337396589826288615608046563246444685656290281023085.
The type is Option<((...(u8,u8,u8,u8,u8,u8),...))>, with 100 levels of nested tuples, where each tuple contains 6 identical items.
type A<T>=(T,T,T,T,T,T);type B<T>=A<A<A<A<A<T>>>>>;type C<T>=B<B<B<B<B<T>>>>>;None::<C<C<C<C<u8>>>>>

Ceylon, 38843546786070481 (~ 4·1016)
[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]

This are 49 nested one-tuples, with an empty tuple innermost.
The short name of this type is actually the same as the value in this case, but the fully expanded name is much longer.
The Ceylon compiler is working forever when trying to compile this (The compiler was still running after 180 minutes) – I'll have to try calculating the theoretical type length.
The problem here is that a one-element-tuple type [X] is actually represented in Ceylon's type system as Tuple<X, X, []> (first parameter is a supertype for all element types, second is the type of the first element, and third the type of all except the first elements, which is here an empty tuple (the empty object, the single instance satisfying the interface Empty)).
So [] is empty, [[]] is Tuple<[], [], []> = Tuple<empty, empty, empty>, [[[]]] is Tuple<[[]], [[]], []> = Tuple<Tuple<[], [], []>, Tuple<[], [], []>, []>. And the full name includes the package names, so we have actually ceylon.language::Tuple<ceylon.language::Tuple<ceylon.language::empty, ceylon.language::empty, ceylon.language::empty>, ceylon.language::Tuple<ceylon.language::empty, ceylon.language::empty, ceylon.language::empty>, ceylon.language::empty> just for three levels. And we want to go to 50.
As ceylon.language::empty is 22 characters long, and each ceylon.language::Tuple<?,?,ceylon.language::empty> adds 47 to twice the result from the previous step, we get f(1) = 22, and f(n) = 2 · f(n-1) + 47. This simplifies to f(n) = 69 · 2^(n - 1) - 47, and entering 50 gives us 38843546786070481. Of course, this is much larger than what would fit in the memory of my computer (8·109 bytes).
Of course, the compiler could be smart and not try to have the whole type name in memory until its name is requested.
Here is the full program trying to print the type:
import ceylon.language.meta {
    type
}
"Run the module `codegolf.signature71797`."
shared void run() {
    value x = [[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]];
    print(type(x));
}

C# (Visual C# Interactive Compiler), 99 bytes, Score 841
(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,1,1))))))))))))))))))))))))

Try it online!
Outputs
System.ValueTuple`2[System.Int32,System.ValueTuple`2[System.Int32,System.ValueTuple`2[System.Int32,System.ValueTuple`2[System.Int32,System.ValueTuple`2[System.Int32,System.ValueTuple`2[System.Int32,System.ValueTuple`2[System.Int32,System.ValueTuple`2[System.Int32,System.ValueTuple`2[System.Int32,System.ValueTuple`2[System.Int32,System.ValueTuple`2[System.Int32,System.ValueTuple`2[System.Int32,System.ValueTuple`2[System.Int32,System.ValueTuple`2[System.Int32,System.ValueTuple`2[System.Int32,System.ValueTuple`2[System.Int32,System.ValueTuple`2[System.Int32,System.ValueTuple`2[System.Int32,System.ValueTuple`2[System.Int32,System.ValueTuple`2[System.Int32,System.ValueTuple`2[System.Int32,System.ValueTuple`2[System.Int32,System.ValueTuple`2[System.Int32,System.ValueTuple`3[System.Int32,System.Int32,System.Int32]]]]]]]]]]]]]]]]]]]]]]]]

Nice one! Adding one m after a 1 would make the byte count reach 100 and the score 843 Try it online!

Haskell, 782
Expression:
sum.sum.sum.sum.sum.sum.sum.sum.sum.sum.sum.sum.sum.sum.sum.sum.sum.sum.sum.sum.sum.sum.sum.sum.sum

Type signature:
:: (Num [[[[[[[[[[[[[[[[[[[[[[[[c]]]]]]]]]]]]]]]]]]]]]]]], Num [[[[[[[[[[[[[[[[[[[[[[[c]]]]]]]]]]]]]]]]]]]]]]], Num [[[[[[[[[[[[[[[[[[[[[[c]]]]]]]]]]]]]]]]]]]]]], Num [[[[[[[[[[[[[[[[[[[[[c]]]]]]]]]]]]]]]]]]]]], Num [[[[[[[[[[[[[[[[[[[[c]]]]]]]]]]]]]]]]]]]], Num [[[[[[[[[[[[[[[[[[[c]]]]]]]]]]]]]]]]]]], Num [[[[[[[[[[[[[[[[[[c]]]]]]]]]]]]]]]]]], Num [[[[[[[[[[[[[[[[[c]]]]]]]]]]]]]]]]], Num [[[[[[[[[[[[[[[[c]]]]]]]]]]]]]]]], Num [[[[[[[[[[[[[[[c]]]]]]]]]]]]]]], Num [[[[[[[[[[[[[[c]]]]]]]]]]]]]], Num [[[[[[[[[[[[[c]]]]]]]]]]]]], Num [[[[[[[[[[[[c]]]]]]]]]]]], Num [[[[[[[[[[[c]]]]]]]]]]], Num [[[[[[[[[[c]]]]]]]]]], Num [[[[[[[[[c]]]]]]]]], Num [[[[[[[[c]]]]]]]], Num [[[[[[[c]]]]]]], Num [[[[[[c]]]]]], Num [[[[[c]]]]], Num [[[[c]]]], Num [[[c]]], Num [[c]], Num [c], Num c) => [[[[[[[[[[[[[[[[[[[[[[[[[c]]]]]]]]]]]]]]]]]]]]]]]]] -> c

Becomes 1814 characters with ghc 8.0.2, as the type of sum then is (Num a, Foldable t) => t a -> a


text:
Math without math class
You receive an input with a number and a string with a space in the middle. The string tells you what you need to do with the number, it can be:
sqrt - square root of number
sqr - square of number
cube - cube of number
abs - absolute of number
round - rounded version of number
You need to output the final result of the calculation with whatever you have.
If your language doesn't have an input, you can hard-code that in.
Rules:
You can't use a math library, even if it is built-in.
You don't get a number or a result bigger than the highest possible one in your language.
Because of the vulnerability of the above rule, you can't use languages, which only support a 1 bit number. (1 and 0)
If your language doesn't support non-integer numbers, you need to output a rounded result.
Test cases
16 sqrt = 4
25 sqr = 625
3 cube = 27
-10 abs = 10
18.38 round = 18
Because this is a code-golf, the shortest answer in bytes wins.
Good luck!

25 sqr = 625?

can sqrt result in decimal values eg 5 sqrt?

Define a built-in math library

@LegionMammal978 Any functionality wich allows you to calculate something other than adding, subtracting, multiplying and dividing. E.g. java and javascript Math class

@dev-null yes, 25*25 is 625

@Bálint Define "calculating something". If I use list indexing then does that count as calculation?

@LegionMammal978 Ok, then any sort of functionality, wich allows you to calculate the squareroot/square/cube/absolute/roubded version of a number is prohibited.

Do we have to support imaginary square roots?

@LegionMammal978 no

@Bálint Javascript's Math is not a class.

It's not clear what can be used to calculate the requested operation. any sort of functionality which allows you to calculate the square root of a number is prohibited makes the challenge, by definition, impossible. You'd also have to clarify what counts as rounding.

Mathematica, 155 153 bytes
{a=ToExpression@#,a a,a a a,c=a~Mod~1,a+Boole[c>=.5]-c,,,,If[Chop@a==0,0,a/Sign@a],If[a>0,(#+a/#)/2&~FixedPoint~1.,0]}[[Hash@#2~Mod~12]]&@@StringSplit@#&

Could probably be golfed further. Doesn't use "any sort of functionality, wich allows you to calculate the squareroot/square/cube/absolute/roubded version of a number."

Bash - 141 137 132
t(){ for((;x*x!=$1;x++));do :;done;}
r(){ ((x=$1*$1));}
e(){ ((x=$1**3));}
s(){ x=${1#-};}
d(){ x=${1%.*};}
${2:${#2}-1} $1
echo $x

Run as
bash math.sh 16 sqrt
bash math.sh 25 sqr
bash math.sh 3 cube
bash math.sh -10 abs
bash math.sh 18.38 round

It strips the operation done to the last character, which is unique for each, then calls the appropriate function with the number

How does the square root work if the number is not a perfect square? Wouldn't it be an infinite loop? (Maybe replace != with < ? Even then the rounding seems wrong)

ES6 - 124 bytes
(a,b)=>eval('_=>'+'{for(c=1;c*c<a;c++);return c}_a*a_a*a*a_a<0?-a:a_a.toFixed()'.split`_`['tresd'.indexOf(b[b.length-1])])()

Square root only works for rounded numbers. Sqrt of 15 will result in 4, I hope this is allowed. Re-writing a fully functional square root function feels like overkill.
Explanation
(a,b)=> // anonymous function
    eval(
        '_=>' + // construct an anonymous function to eval
        '{for(c=1;c*c<a;c++);return c} // sqrt
        _ // seperator
        a*a // sqr
        _
        a*a*a // cube
        _
        a<0?-a:a // abs
        _
        a.toFixed()' // round
        .split`_` // create an array of functions
        [ // select the function to use
            'tresd'.indexOf(b[b.length-1]) // get index of input
        ]
    )() // end eval and call the returned function

Golfing tips are welcome
Test cases:

f=
(a,b)=>eval('_=>'+'{for(c=1;c*c<a;c++);return c}_a*a_a*a*a_a<0?-a:a_a.toFixed()'.split`_`['tresd'.indexOf(b[b.length-1])])()

F=(a,b)=>document.body.innerHTML+='<pre>'+a+', '+b+':\n'+f(a,b)+'\n</pre>';

F(16,'sqrt')
F(25,'sqr')
F(3,'cube')
F(-10,'abs')
F(18.38,'round')

It is. As some of the people mentioned here, you can use the last letter of the input instead of the whole word, because it is unique for every type.

Python 2, 153 bytes
S=str.split;x,f=S(raw_input())
exec'print '+dict(zip('tresd',S('[a for a in range(x)if a*a==x][0]|x*x|x**3|abs(x)|round(x)','|')))[f[-1]].replace('x',x)

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

sort: votes


text:
Filter out and add up
Task
The task is very simple. Given a non-empty string containing numbers, uppercase and lowercase letters, output the sum of the remaining numbers. For example:
a1wAD5qw45REs5Fw4eRQR33wqe4WE

Filtering out all the letters would result into:
 1   5  45   5  4    33   4

The sum of these numbers is 1 + 5 + 45 + 5 + 4 + 33 + 4 = 97. So the output would be 97.
Test Cases
a > 0
0 > 0
5 > 5
10 > 10
a0A > 0
1a1 > 2
11a1 > 12
4dasQWE65asAs5dAa5dWD > 79
a1wAD5qw45REs5Fw4eRQR33wqe4WE > 97

This is code-golf, so the submission with the least amount of bytes wins!

I knew I had written that Labyrinth program before... here is the same challenge but with negative numbers as well (which makes a surprisingly big difference for some languages, so I don't think they're dupes).

@MartinBüttner Looks like that one doesn't include negative numbers: "-n (where n is an integer) is not counted as a negative n, but as a hyphen followed by n."

Oh, I see what you mean. You're saying it has hyphens and this one doesn't.

GS2, 2 bytes
Wd

Try it online!
How it works
W     Read all numbers.
      For input x, this executes map(int, re.findall(r'-?\d+', x)) internally.
 d    Compute their sum.

Well, this was unexpected...

@Adnan: It's Dennis. Given enough time he can find a solution to any code golf in less than 4 bytes.

Labyrinth, 8 bytes
Take that, Pyth...
?+
;,;!@

Try it online!
Explanation
The usual primer (stolen from Sp3000):

Labyrinth is 2D and stack-based. Stacks have an infinite number of zeroes on the bottom.
When the instruction pointer reaches a junction, it checks the top of the stack to determine where to turn next. Negative is left, zero is forward and positive is right.

What comes in really handy here is that Labyrinth has two different input commands, , and ?. The former reads a single byte from STDIN, or -1 at EOF. The latter reads an integer from STDIN. It does so skipping everything that isn't a number and then reads the first decimal number it finds. This one returns 0 at EOF, so we can't use it to check for EOF reliably here.
The main loop of the program is this compact bit:
?+
;,

With ? we read an integer (ignoring all letters), with + we add it to the running total (which starts out as one of the implicit zeroes at the stack bottom). Then we read another character with , to check for EOF. As long as we're not at EOF, the read character will be a letter which has a positive character code, so the IP turns right (from its point of view; i.e. west). ; discards the character because we don't need it and then we enter the loop again.
Once we're at EOF, , pushes a -1 so the IP turns left (east) instead. ; again discards that -1, ! prints the running total as an integer and @ terminates the program.

Awesome stuff Martin!

MATL, 8 bytes
1Y4XXXUs

Try it online!
1Y4      % predefined literal: '\d+'
XX       % implicit input. Match regular expression. Returns a cell array of strings
         % representing numbers
XU       % convert each string to a double. Returns a numeric array
s        % sum of numeric array

CJam, 13 bytes
Fixed to work with input without numbers thanks to Dennis! Also saved a byte by replacing the letters array with an array of ASCII above code point 64. And then another byte saved by Dennis!
q_A,s-Ser~]1b

Simple transliteration from letters to spaces, then eval and sum. Try it online.

JavaScript ES6, 35 bytes
s=>eval(s.replace(/\D+/g,'+')+'.0')

How it works
First, we replace each string of non-digits with "+". There are basically four different ways that this could end up:
1. 1b23c456   => 1+23+456
2. a1b23c456  => +1+23+456
3. 1b23c456d  => 1+23+456+
4. a1b23c456d => +1+23+456+

Cases 1 and 2 are taken care of already. But we somehow need to fix the last + so that it doesn't cause an error. We could remove it with .replace(/\+$,""), but that's too expensive. We could append a 0 to the end, but that would affect the last number if the string does not end with a +. A compromise is to append .0, which is both a valid number on its own and doesn't affect the value of other integers.
Here's a few other values that would work as well:
.0
-0
 +0
-""
-[]
0/10
0e-1
.1-.1

Alternate version, also 35 bytes
s=>s.replace(/\d+/g,d=>t+=+d,t=0)|t

Another alternate version, 36 bytes
s=>s.split(/\D/).map(d=>t+=+d,t=0)|t

Retina, 22 11
\d+
$0$*1
1

Try it online!
11 bytes (!) saved thanks to Martin!
Basically just decimal to unary then count the 1s.

I should probably make $0 implicit if a substitution starts with $*. It's a very common pattern and that would have let you beat Pyth. ;)

@MartinBüttner While you're at it you could make the right character default to something too :O

hm, not a bad idea. I'll think about it.

Japt, 2 bytes
Nx

Test it online!
How it works
N    // Implicit: N = (parse input for numbers, "strings", and [arrays])
x    // Sum. Implicit output.

I'm getting an error "Japt.stdout" must be sent to an HTMLElement

@Downgoat This happens occasionally; I'm not sure why. Reloading the page seems to fix this.

Pyth, 12 11 10 bytes
ssM:z"\D"3

    z        autoinitialized to input()
   : "\D"3   split on non-digits
 sM          convert all elements of resulting array to ints
s            sum

Fortunately, s (convert to int) returns 0 when applied to the empty string, so I don't have to worry about the fact that split("a1b", "\D+") returns ["", "1", ""]. Similarly, split("a", "\D+") returns ["", ""].
This even allows me to split on every non-digit individually, since 1 + 0 + 0 + 0 + 0 + 2 is the same thing as 1 + 2.
Thanks to Thomas Kwa for a byte!

Gol><>, 4 bytes
iEh+

So short I need dummy text...

Perhaps you should explain your code with your extra space :)

Perl 6, 18 bytes
{[+] .comb(/\d+/)}
{[+] .split(/\D/)}

Usage:
my &code = {[+] .comb(/\d+/)}

say code 'a'; # 0
say code '0'; # 0
say code '5'; # 5
say code '10'; # 10
say code 'a0A'; # 0
say code '1a1'; # 2
say code '11a1'; # 12
say code '4dasQWE65asAs5dAa5dWD'; # 79
say code 'a1wAD5qw45REs5Fw4eRQR33wqe4WE'; # 97

Saves a byte to use a whatevercode block: *.comb(/\d+/).sum

@Steffan I believe that may have been before the .sum method was added to the language. Which if I recall correctly would make it unavailable according to the rules.

That rule has changed since, you can now use languages newer than the challenge. I didn't know that Raku never had a sum method though

@Steffan. Originally Raku did not have sum of any sort. Partially because sum(1..5) could be written using the reduce meta operator [+](1..5). At some point it became obvious that there could be an optimization if the input was a range. A range could calculate its sum without going over its contents. So now the meta operator [+]... gets converted to sum which will allow for this optimization to take place. Basically the only reason sum was added is as an optimization. https://github.com/rakudo/rakudo/commit/6d970110df1c9fc160833137c66d8394b8b9b328

Jelly, 6 bytes
&-ṣ-ḌS

Try it online!
How it works
&-ṣ-ḌS  Main link. Input: L (string)

&-      Take the bitwise AND of L's characters and -1.
        This attempts to cast to int, so '0' & -1 -> 0 & -1 -> 0.
        On failure, it returns the integer argument (if any), so 'a' & -1 -> -1.
  ṣ-    Split the resulting list at occurrences of -1.
    Ḍ   Convert each chunk from decimal to integer. In particular, [] -> 0.
     S  Compute the sum of the results.

Perl, 21 + 1 = 22 bytes
$_=eval join"+",/\d+/g

Requires the -p flag:
$ perl -pe'$_=eval join"+",/\d+/g' <<< 'a1wAD5qw45REs5Fw4eRQR33wqe4WE'
97

Does this work when there aren't any numbers? e.g. a?

@FryAmTheEggman Good question, I guess it will print nothing which in a numeric context is 0 ;-)

Julia, 35 bytes
s->sum(parse,matchall(r"\d+","0"s))

This is an anonymous function that accepts a string and returns an integer. To call it, assign it to a variable.
We use matchall to get an array consisting of matches of the regular expression \d+, which are just the integers in the string. We have to tack on a 0 to the front of the string, otherwise for cases like "a", we'd be summing over an empty array, which causes an error. We then apply parse to each string match, which converts to integers, and take the sum.

parse can become int if you don't mind the deprecation warning.

@Dennis I do though ._.

Vyxal s, 4 bytes
⁽±Ḋ⌊

Try it Online!

Ruby -n, 23 bytes
Based on Ventero’s answer here.
p eval$_.scan(/\d+/)*?+

Attempt This Online!

alternative 23 you might enjoy

Javascript, 32 39 bytes
s=>eval((s.match(/\d+/g)||[0]).join`+`)

f=
s=>eval((s.match(/\d+/g)||[0]).join`+`)

F=s=>document.body.innerHTML+='
f(\''+s+'\') -> '+f(s)+'\n
'

F('a')
F('5')
F('10')
F('1a1')
F('11a1')
F('4dasQWE65asAs5dAa5dWD')
F('a1wAD5qw45REs5Fw4eRQR33wqe4WE')

Mathematica, 51 bytes
Total@ToExpression@StringCases[#,DigitCharacter..]&

Catching the wrong end of the verbose Mathematica builtins. 1 Byte off with the help of @DavidC

DigitCharacter .. will save 1 byte

DigitCharacter doesn't work as written because it removes all the digits whereas we want to remove all the letters...

you are right.  I was thinking of Total@ ToExpression@StringCases[#, DigitCharacter ..] &

I see! Yeah that change saves a byte.

48 bytes by replacing Total with Tr

PHP, 64 bytes
<?php preg_match_all("/\d+/",$argv[1],$a);echo array_sum($a[0]);

Run it as
php -f filterOutAndAddUp.php <test_case>

https://eval.in/517817

Welcome to Programming Puzzles and Stack Exchange. This is a great answer (+1), however it could be improved by adding a code explanation and breakdown. Also, could you use <? instead of <?php?

R, 46 43 bytes
sum(strtoi(strsplit(scan(,''),'\\D')[[1]]))

Explanation
                    scan(,'')                  # Take the input string
           strsplit(         ,'\\D')           # Returns list of all numeric parts of the string
                                    [[1]]      # Unlists to character vector
    strtoi(                              )     # Converts to numeric vector
sum(                                      )    # Sums the numbers

Sample run
> sum(strtoi(strsplit(scan(,''),'\\D')[[1]]))
1: a1wAD5qw45REs5Fw4eRQR33wqe4WE
2:
Read 1 item
[1] 97

Edit: Replaced [^0-9] with \\D.

Welcome to Programming Puzzles and Code Golf. This is a great first answer; however it would be improved by adding a code explanation and breakdown, so we know how it works.

Factor + math.unicode sorting.human, 36 bytes
[ find-numbers [ real? ] filter Σ ]

Attempt This Online!
                  ! "11a1"
find-numbers      ! { "" 11 "a" 1 }
[ real? ] filter  ! { 11 1 }
Σ                 ! 12

Clojure/ClojureScript, 35 bytes
#(apply +(map int(re-seq #"\d+"%)))

Bash + GNU utilities, 29
grep -Eo [0-9]+|paste -sd+|bc

If it is required to support input with no numbers (e.g. a), then we can do this:
Bash + GNU utilities, 38
1 byte saved thanks to @TobySpeight.
(grep -Eo [0-9]+;echo 0)|paste -sd+|bc

This prints nothing for input a. We are currently discussing whether that's valid or not.

@Dennis.  Ok.  I added another version to cover both eventualities.

You could use ; instead of || to always add zero, for no harm.

@TobySpeight Yes, thats good - thanks!

PowerShell, 28 26 bytes
$args-replace"\D",'+0'|iex

Takes input $args then does a regex -replace to swap the letters with +0, then pipes that to iex (short for Invoke-Expression and similar to eval).
PS C:\Tools\Scripts\golfing> .\filter-out-and-add-up.ps1 'a1wAD5qw45REs5Fw4eRQR33wqe4WE'
97

Alternatively
If you're OK with some extraneous output, you can do the following, also at 28 26 bytes:
$args-split"\D"|measure -s

This will take the input string $args and -split it into an array-of-strings on the non-numbers (removing them in the process). For example, 1a2b33 would turn into ['1','2','33']. We pipe that to Measure-Object with the -Sum parameter. Output would be like the below:
PS C:\Tools\Scripts\golfing> .\filter-out-and-add-up.ps1 'a1wAD5qw45REs5Fw4eRQR33wqe4WE'

Count    : 21
Average  :
Sum      : 97
Maximum  :
Minimum  :
Property :

Edit -- durr, don't need the [ ] in the regex since I'm no longer specifying a list of possible matches ...

Gema, 39 characters
<D>=@set{s;@add{${s;};$0}}
?=
\Z=${s;0}

Sample run:
bash-4.3$ gema '<D>=@set{s;@add{${s;};$0}};?=;\Z=${s;0}' <<< 'a1wAD5qw45REs5Fw4eRQR33wqe4WE'

Seriously, 13 bytes
,ú;û+@s`≈`MΣl

Try it online!
Explanation:
,ú;û+@s`≈`MΣl
,              push input
 ú;û+          push "abc...zABC...Z" (uppercase and lowercase English letters)
     @s        split on letters
       `≈`M    convert to ints
           Σ   sum
            l  length (does nothing to an integer, pushes 0 if an empty list is left, in the case where the string is all letters)

@Adnan Good catch - it outputs the empty list with a. Should be a one-byte fix.

Java, 70 bytes
s->{int n=0;for(String i:s.split("\\D+"))n+=Long.valueOf(i);return n;}

TI-Basic, 106 bytes
Works on TI-83/84 calculators!
Input Str1
"{0,→Str2
Str1+"N0→Str1
For(I,1,length(Ans
sub(Str1,I,1
If inString("0123456789",Ans
Then
Str2+Ans→Str2
Else
If ","≠sub(Str2,length(Str2),1
Str2+","→Str2
End
End
sum(expr(Ans

Python 2, 70 bytes
I am putting a Python answer just for fun.
import re
j=0
for i in map(int,re.findall('\d+',input())):j+=i
print j

Very simple and uses regex to find all the numbers in the input. Try it online!

In this context you have to use raw_input or switch to python3. A smaller version (py3, 56 bytes) :  import re;print(sum(map(int,re.findall('\d+',input())))).

Ruby 45 bytes
$*[0].split(/[a-z]/i).map(&:to_i).inject 0,:+

(First attempt at work, will revisit this)

POSIX sh + tr + dc, 27 25 bytes
dc -e "0d`tr -sc 0-9 +`p"

Converts any run of non-digits (including the terminating newline) to + operator, pushes two zeros onto the stack (in case input begins with non-digit), adds them all and prints the result.  There may be an extra zero remaining at bottom of stack, but we don't care about that.

Lua, 51 Bytes
Pretty short for once! Even shorter than Java! The input must be a command-line argument for it to work.
a=0 arg[1]:gsub("%d+",function(c)a=a+c end)print(a)

Ungolfed
a=0                 -- Initialize the sum at 0
arg[1]:gsub("%d+",  -- capture each group of digits in the string
  function(c)       -- and apply an anonymous function to each of them
  a=a+c             -- sums a with the latest group captured
end)
print(a)            -- output a

R, 50 bytes
Requires having gsubfn installed
sum(gsubfn::strapply(scan(,''),'\\d+',strtoi)[[1]])

Uses strtoi to coerce to numeric

Oracle SQL 11.2, 105 bytes
SELECT NVL(SUM(TO_NUMBER(COLUMN_VALUE)),0)FROM XMLTABLE(('"'||regexp_replace(:1,'[a-zA-Z]','","')||'"'));

The regex convert alpha characters to ','
XMLTABLE create one row per item in the string using ',' as the separator.
SUM the rows to get the result.
NVL is needed to account for a string with no digit.

Python 2, 71 bytes
I just had to make one-liner, though it costs a whole byte more than @TanMath's answer
sum(map(int,"".join([i*i.isdigit()or" "for i in raw_input()]).split()))

Explaination:
raw_input()                             - Input
"".join([i*i.isdigit()or" "for i in _]) - Replace non-digits with spaces
map(int, _.split())                     - Split on spaces, and convert to number
sum(_)                                  - Sum the resulting list

Japt v2.0a0 -x, 3 bytes
'Cause ETH's solution is a bit cheaty!
q\D

Try it
q\D     :Implicit input of string
q       :Split on
 \D     :  RegEx /\D/ (or /[^0-9]/)
        :Implicit output of sum of resulting array

Pip, 6 bytes
$+a@XI

Try It Online!
Explanation
    XI  Built-in regex matching integers
   @    Find all matches in
  a     Command-line input
$+      Fold on addition

J-uby, 19 bytes
~:scan&/\d+/|:sum+Z

Attempt This Online!

J + regex, 21 bytes
1#.0,'\d+'".&>@rxall]

Attempt This Online!
1#.0,'\d+'".&>@rxall]
     '\d+'     rxall]  NB. find all matches of /\d+/ in right arg ]
              @        NB. then execute the monadic verb...
          ".&>         NB. eval each boxed match and unbox result
   0,                  NB. prepend 0 in case of no match
1#.                    NB. sum integer array

If adding the script to the language isn't allowed, then that adds 14 bytes for a total of 35.
1#.0,'\d+'".&>@rxall(load'regex')]]

The only difference is the fork (load'regex')]] that loads the library and simply returns the function arg using dyadic ].

jq -R, 31 bytes
[splits("\\D")|tonumber?]|0+add

Try it online!

Uiua, 19 12 bytes
/+⊜parse≤@9.

Try it!
-7 thanks to Bubbler
/+⊜parse≤@9.
           .  # duplicate
        ≤@9   # where are the characters less than or equal to 9?
  ⊜parse      # partition to an array of integers
/+            # sum

⊜ partition is the perfect built-in here, so /+⊜parse≤@9. works for 12. ≤@9 works because there are no letters below digits.

@Bubbler Nice. Thanks!

05AB1E (legacy), 3 bytes
á¡O

Try it online or verify all test cases.
In the new version of 05AB1E it would have been 2 bytes longer, because ¡ now supports substrings to split on (in the legacy version a string argument would be interpret as a list of characters implicitly) and will keep empty strings:
áS¡þO

Try it online or verify all test cases.
Explanation:
       # Example input: "a1wAD5qw45REs5Fw4eRQR33wqe4WE"

       # (legacy version)
á      # Only keep the letters of the (implicit) input-string
       #  STACK: "awADqwREsFweRQRwqeWE"
 ¡     # Split the (implicit) input-string on those characters
       #  STACK: ["1","5","45","5","4","33","4"]
  O    # Sum the remaining numbers
       #  STACK: 97
       # (which is output implicitly as result)

       # (new version)
á      # (same as above)
 S     # Split it to a list of characters
       #  STACK: ["a","w","A","D","q","w","R","E","s","F","w","e","R","Q","R","w","q","e","W","E"]
  ¡    # Split the (implicit) input-string on those characters
       #  STACK: ["","1","","","5","","45","","","5","","4","","","","33","","","4","",""]
   þ   # Remove all empty strings, by only keeping numbers
       #  STACK: ["1","5","45","5","4","33","4"]
    O  # (same as above)

q, 41 20 bytes
sum value .Q.n .Q.n?

k, 23 14 bytes
+/. .Q.n .Q.n?

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/


text:
How even is a number?
The ancient Greeks had these things called singly and doubly even numbers. An example of a singly even number is 14. It can be divided by 2 once, and has at that point become an odd number (7), after which it is not divisible by 2 anymore. A doubly even number is 20. It can be divided by 2 twice, and then becomes 5.
Your task is to write a function or program that takes an integer as input, and outputs the number of times it is divisible by 2 as an integer, in as few bytes as possible. The input will be a nonzero integer (any positive or negative value, within the limits of your language).
Test cases:
14 -> 1

20 -> 2

94208 -> 12

7 -> 0

-4 -> 2

The answer with the least bytes wins.
Tip: Try converting the number to base 2. See what that tells you.

@AlexL. You could also look at it is never becoming odd, so infinitely even. I could save a few bytes if a stack overflow is allowed ;)

I'm voting to close for now until clarification is added. The answers have varying outputs, and that's not helpful to the site.

@AlexL. I guess it would best be indefinite, though I'm not a mathematician.

The input will be a nonzero integer Does this need to be edited following your comment about zero being a potential input?

This is called the 2-adic valuation or 2-adic order.

By the way, according to Wikipedia, the p-adic valuation of 0 is defined as infinity.

@Paul I call it the lowest set bit. Thanks for your info.

@Paul think it's okay if my submission evaluates its 2-adic order as -Infinity according to Math.log2(0)?

This is the "find first set" or "count trailing zeroes" function, right?

What an odd question!

https://oeis.org/A001511

Jelly, 2 bytes
ọ2

Try it online!
How it works
ọ2 - Main link. Takes n on the left
ọ  - How many times is n divisible by...
 2 - ...2?

After 4 years, we've got a new winner!

x86_64 machine code, 4 bytes
The BSF (bit scan forward) instruction does exactly this!
0x0f    0xbc    0xc7    0xc3

In gcc-style assembly, this is:
    .globl  f
f:
    bsfl    %edi, %eax
    ret

The input is given in the EDI register and returned in the EAX register as per standard 64-bit c calling conventions.
Because of two's complement binary encoding, this works for -ve as well as +ve numbers.
Also, despite the documentation saying "If the content of the source operand is 0, the content of the destination operand is undefined.", I find on my Ubuntu VM that the output of f(0) is 0.
Instructions:

Save the above as evenness.s and assemble with gcc -c evenness.s -o evenness.o
Save the following test driver as evenness-main.c and compile with gcc -c evenness-main.c -o evenness-main.o:

#include <stdio.h>

extern int f(int n);

int main (int argc, char **argv) {
    int i;

    int testcases[] = { 14, 20, 94208, 7, 0, -4 };

    for (i = 0; i < sizeof(testcases) / sizeof(testcases[0]); i++) {
        printf("%d, %d\n", testcases[i], f(testcases[i]));
    }

    return 0;
}

Then:

Link: gcc evenness-main.o evenness.o -o evenness
Run: ./evenness

@FarazMasroor asked for more details on how this answer was derived.
I am more familiar with c than the intricacies of x86 assembly, so typically I use a compiler to generate assembly code for me.  I know from experience that gcc extensions such as __builtin_ffs(), __builtin_ctz() and __builtin_popcount() typically compile and assemble to 1 or 2 instructions on x86.  So I started out with a c function like:
int f(int n) {
    return __builtin_ctz(n);
}

Instead of using regular gcc compilation all the way to object code, you can use the -S option to compile just to assembly - gcc -S -c evenness.c.  This gives an assembly file evenness.s like this:
    .file   "evenness.c"
    .text
    .globl  f
    .type   f, @function
f:
.LFB0:
    .cfi_startproc
    pushq   %rbp
    .cfi_def_cfa_offset 16
    .cfi_offset 6, -16
    movq    %rsp, %rbp
    .cfi_def_cfa_register 6
    movl    %edi, -4(%rbp)
    movl    -4(%rbp), %eax
    rep bsfl    %eax, %eax
    popq    %rbp
    .cfi_def_cfa 7, 8
    ret
    .cfi_endproc
.LFE0:
    .size   f, .-f
    .ident  "GCC: (Ubuntu 4.8.4-2ubuntu1~14.04.1) 4.8.4"
    .section    .note.GNU-stack,"",@progbits

A lot of this can be golfed out.  In particular we know that the c calling convention for functions with int f(int n); signature is nice and simple - the input param is passed in the EDI register and the return value is returned in the EAX register.  So we can take most of instructions out - a lot of them are concerned with saving registers and setting up a new stack frame.  We don't use the stack here and only use the EAX register, so don't need to worry about other registers.  This leaves "golfed" assembly code:
    .globl  f
f:
    bsfl    %edi, %eax
    ret

Note as @zwol points out, you can also use optimized compilation to achieve a similar result.  In particular -Os produces exactly the above instructions (with a few additional assembler directives that don't produce any extra object code.)
This is now assembled with gcc -c evenness.s -o evenness.o, which can then be linked into a test driver program as described above.
There are several ways to determine the machine code corresponding to this assembly.  My favourite is to use the gdb disass disassembly command:
$ gdb ./evenness
GNU gdb (Ubuntu 7.7.1-0ubuntu5~14.04.2) 7.7.1
...
Reading symbols from ./evenness...(no debugging symbols found)...done.
(gdb) disass /r f
Dump of assembler code for function f:
   0x00000000004005ae <+0>: 0f bc c7    bsf    %edi,%eax
   0x00000000004005b1 <+3>: c3  retq
   0x00000000004005b2 <+4>: 66 2e 0f 1f 84 00 00 00 00 00   nopw   %cs:0x0(%rax,%rax,1)
   0x00000000004005bc <+14>:    0f 1f 40 00 nopl   0x0(%rax)
End of assembler dump.
(gdb)

So we can see that the machine code for the bsf instruction is 0f bc c7 and for ret is c3.

Do we not count this as 2?

@ThomasKwa I suppose that could be argued.  I don't think that could be used as a complete function or program that the question is asking for though.  I've not done a machine code-only answer before, but my feeling is that should always be at least a ret instruction at the end so that it is usable

How do I learn Machine Language / Byte dump code? Can't find anything online

This does not satisfy the C calling convention. On x86-32, the argument is passed on the stack; on x86-64, the argument is passed in %rdi. It only appears to work within your test harness because your compiler happens to have left a stale copy of the argument in %eax. It will break if you compile the harness evenness-main.c with different optimization settings; for me it breaks with -O, -O2, or -O3.

@AndersKaseorg - thanks for pointing that out.  I've restricted it just to x86_64 now, so that input comes in RDI.

@AndersKaseorg what if I specify regcall?

You could have had the compiler "golf" the assembly language for you by turning on optimization ;-)

@FarazMasroor read the manual.

"Also, despite the documentation saying [...]" -- Any value you get necessarily agrees with the documentation. That doesn't rule out other processor models giving a different value than yours.

@zwol yes  -Os produces exactly the right instructions.

0F BC C7 C3 is a better way to show the hex dump.

Python, 25 bytes
lambda n:len(bin(n&-n))-3

n & -n zeroes anything except the least significant bit, e.g. this:
100010101010100000101010000
            v
000000000000000000000010000

We are interested in the number of trailing zeroes, so we convert it to a binary string using bin, which for the above number will be "0b10000". Since we don't care about the 0b, nor the 1, we subtract 3 from that strings length.

after posting my answer I figured yours was very smart, so I tried to convert it to Pyth and see if yours was shorter than mine. It yielded l.&Q_Q, using log2 instead of len(bin(_)). It was the same length as my Pyth answer as well as another Pyth answer, it seems this doesn't get shorter than 6 bytes in Pyth...

Jelly, 4 bytes
Æfċ2

In the latest version of Jelly, ÆEḢ (3 bytes) works.
Æf      Calculate the prime factorization. On negative input, -1 appended to the end.
  ċ2    Count the 2s.

Try it here.

This works for negative input too.

@ThomasKwa I don't think that counts. Maybe a meta question?

Isn't ÆEḢ fine? It actually outputs 0 for odd numbers.

@busukxuan It doesn't work for ±1.

@ThomasKwa Odd, it seems to be working in my browser.

@busukxuan Hmm, I think Dennis must have just pushed it.

Looks like 6 bytes to me: c3 86 45 e1 b8 a2

@Tyzoid Jelly uses its own code page on the offline interpreter by default, in which one char is one byte.

In modern Jelly, this is a built-in: ȯ2

Pyth, 6 bytes
/P.aQ2

Try it here.
 P.aQ         In the prime factorization of the absolute value of the input
/    2        count the number of 2s.

JavaScript (ES6), 18 bytes
n=>Math.log2(n&-n)

4 bytes shorter than 31-Math.clz32. Hah.

Oh wow, and I only recently learned about Math.clz32 too...

Damn I was going to post exactly this! +1

JavaScript ES6, 22 19 bytes
f=x=>x%2?0:f(x/2)+1

Looks like recursion is the shortest route.

Oh nooo! You beat me! Nicely done :) +1

MATL, 5 bytes
Yf2=s

This works for all integers.
Try it online!
Yf      % implicit input. Compute (repeated) prime factors. For negative input
        % it computes the prime factors of the absolute value, except that for
        % -1 it produces an empty array instead of a single 1
2=s     % count occurrences of "2" in the array of prime factors

"And now, for something completely different..."

Pyth, 6 bytes
x_.BQ1

Basically just
convert2BinString(evaluatedInput())[::-1].index("1")

Pyth, 8 bytes
lec.BQ\1

     Q    autoinitialized to eval(input())
   .B     convert to binary string
  c   \1  split on "1", returning an array of runs of 0s
 e        get the last run of 0s, or empty string if number ends with 1
l         take the length

For example, the binary representation of 94208 is:
10111000000000000

After splitting on 1s and taking the last element of the resulting array, this becomes:
000000000000

That's 12 zeroes, so it's "12-ly even."
This works because x / 2 is essentially x >> 1—that is, a bitshift right of 1. Therefore, a number is divisible by 2 only when the LSB is 0 (just like how a decimal number is divisible by 10 when its last digit is 0).

05AB1E, 4 5 bytes
Now supports negative numbers. Code:
Äb1¡g

Try it online!
Explanation:
Ä      # Abs(input)
 b     # Convert the number to binary
  1¡   # Split on 1's
    g  # Take the length of the last element

Uses CP-1252 encoding.

Doesn't seem to function properly. Your test case for TIO, -94208, returns 2 instead of 12.

C, 36 (28) bytes
int f(int n){return n&1?0:f(n/2)+1;}

(Not testing for zero argument as a nonzero argument was specified.)
Update (in response to comment): If we allow K&R style function declarations, then we can have a 28-byte version:
f(n){return n&1?0:f(n/2)+1;}

In this case, we rely on the fact that the compiler defaults both n and the return type of f to int. This form generates a warning with C99 though and does not compile as valid C++ code.

If you change int n -> n it is still valid C code and cuts off 4 characters.

Good point. I was going to say that that triggers at least a warning with C99, but so does omitting the return type. And both trigger errors in C++. So I am changing my answer appropriately.

Java 7, 39 or maybe 44 bytes
int s(int a){return a%2!=0?0:s(a/2)+1;}

int s(int a){return a%2!=0|a==0?0:s(a/2)+1;}

Yay recursion! I had to use a != instead of a shorter comparison so it wouldn't overflow on negative input, but other than that it's pretty straightforward. If it's odd, send a zero. If even, add one and do it again.
There are two versions because right now output for zero is unknown. The first will recurse until the stack overflows, and output nothing, because 0 is infinitely even. The second spits out a nice, safe, but probably-not-mathematically-rigorous 0 for output.

Ruby 24 bytes
My first code golf submission (yey!)
("%b"%$*[0])[/0*$/].size

How I got here:
First I wanted to get code that actually fulfilled the spec to get my head around the problem, so I built the method without regards to number of bytes:
def how_even(x, times=1)
  half = x / 2
  if half.even?
    how_even(half, times+1)
  else
    times
  end
end

with this knowledge I de-recursed the function into a while loop and added $* (ARGV) as the input and i as the count of how many times the number has been halved before it becomes odd.
x=$*[0];i=1;while(x=x/2)%2<1;i+=1;end;i

I was quite proud of this and almost submitted it before it struck me that all this dividing by two sounded a bit binary to me, being a software engineer but not so much a computer scientist this wasn't the first thing that sprung to mind.
So I gathered some results about what the input values looked like in binary:
input      in binary      result
---------------------------------
   14               1110   1
   20              10100   2
94208  10111000000000000  12

I noticed that the result was the number of positions to the left we have to traverse before the number becomes odd.
Doing some simple string manipulations I split the string on the last occurrence of 1 and counted the length of remaining 0s:
("%b"%$*[0])[/0*$/].size

using ("%b" % x) formatting to turn a number to binary, and String#slice to slice up my string.
I have learnt a few things about ruby on this quest and look forward to more golfs soon!

Welcome to Programming Puzzles and Code Golf Stack Exchange. This is a great answer; I really like the explanation. +1! If you want more code-golf challenges, click on the [tag:code-golf] tag. I look forward to seeing more of your answers.

Feel free to ask me about any questions you have. Type @wizzwizz4 at the beginning of a comment to reply to me. (This works with all usernames!)

JavaScript (ES6), 20 bytes 19 bytes.
f=x=>~x%2&&1+f(x/2)

This is a port of the Haskell solution by @nimi to JavaScript. It uses the "short-circuit" properties of && which returns its left side if it is falsey (which in this case is -0) or else returns its right side. To implement odd x = 0 we therefore make the left hand side 1 - (x % 2) which bubbles 0 through the &&, otherwise we recurse to 1 + f(x / 2).
The shaving of 1 - (x % 2) as (~x) % 2 is due to @Neil below, and has the strange property that causes the above function to emit -0 for small odd numbers. This value is a peculiarity of JS's decision that integers are IEEE754 doubles; this system has a separate +0 and -0 which are special-cased in JavaScript to be === to each other. The ~ operator computes the 32-bit-signed-integer bitwise inversion for the number, which for small odd numbers will be a negative even number. (The positive number Math.pow(2, 31) + 1 for example produces 0 rather than -0.) The strange restriction to the 32-bit-signed integers does not have any other effects; in particular it does not affect correctness.

~x&1 is a byte shorter than 1-x%2.

@Neil Very cool. That has a somewhat counter-intuitive property but I'll take it anyway.

I was trying to come up with a new JS solution and came up with f=x=>x%2?0:1+f(x/2). It is nearly identical to your answer so I'm going to refrain from posting it as a separate answer.

Perl 6, 23 18 bytes
{+($_,*/2...^*%2)}

usage
> my &f = {+($_,*/2...^*%2)}
-> ;; $_? is raw { #`(Block|117104200) ... }
> f(14)
1
> f(20)
2
> f(94208)
12
> f(7)
0
> f(-4)
2

C, 37 bytes
f(int x){return x?x&1?0:1+f(x/2):0;}
Recursively check the last bit until it's not a 0.

Also, there is f(int n){return __builtin_ctz(n);} if you're willing to use gcc extensions.  Or even #define f __builtin_ctz

Remove int . It's implicit, just like the return type.

@luserdroog, You mean f(n){...}? GCC won't compile it. I'm no C expert, but a quick search reveals that maybe this feature was removed in more recent versions of C. So maybe it will compile with the appropriate flags?

@AndySoffer I see. Maybe -ansi or -gnu99? I know I've gotten it to work. I wrote a tips answer about it!

J, 6 bytes
1&q:@|

Explanation:
     |    absolute value
1&q:      exponent of 2 in the prime factorization

APL (Dyalog Unicode), 10 bytes
My 100th answer.
⊥⍨∘~2∘⊥⍣¯1

Try it online!
Explanation:
⊥⍨∘~2∘⊥⍣¯1
    2∘⊥⍣¯1   ⍝ convert the number to binary.
   ~         ⍝ negate it
⊥⍨           ⍝ count trailing ones in the negated number,
             ⍝ effectively counting trailing zeros in the number,
             ⍝ effectively counting how many times is the number divisible by 2.

100 rep to your 100th answer... nice

Java, 27 bytes
Long::numberOfTrailingZeros

Try it online!
Explanation
The number of times a number can be divided by 2 is equal the number of 0s after the rightmost 1 in its binary representation; Java has a built-in method for finding this. Using Long instead of Integer saves 3 bytes.
See also: Long.numberOfTrailingZeros documentation

Vyxal, 2 bytes
2Ǒ

Try it Online!
This one by @lyxal
2Ǒ # I'm running out of things to say for this comment line
 Ǒ # How many times is the input divisible by...
2  # 2

Vyxal, 4 bytes
Eġ∆l

Try it Online!
Ported from the Desmos answer.
Eġ∆l # 4 bytes!
E    # 2^input
 ġ   # GCD of that and the input
  ∆l # log2

Vyxal, 5 bytes
bṘȧ1ḟ

Try it Online!
Strategy from the osabie answer. Suprised that there has been no Vyxal answer for a such a popular question. Bit twiddling also gives 5 bytes.
bṘȧ1ḟ # This comment line needs some love
b     # Convert to binary
 Ṙ    # Reverse
  ȧ   # Absolute value of each element in the list. This is to handle negative numbers correctly
   1ḟ # First index of 1

Try it Online! for 2 bytes because there's a built-in for that

Wait what? I was searching for such a builtin for so long

Rust, 18 bytes
i8::trailing_zeros

Attempt This Online!
It's a builtin :) Replace i8 with any other integer type and it will also work.

Haskell, 28 bytes
f x|odd x=0|1<2=1+f(div x 2)

Usage example: f 94208-> 12.
If the number is odd, the result is 0, else 1 plus a recursive call with half the number.

div x 2? Why not x/2?

@CatsAreFluffy: Haskell has a very strict type system. div is integer division, / floating point division.

Befunge, 20
&:2%#|_\1+\2/#
   @.<

Code execution keeps moving to the right and wrapping around to the second character of the first line (thanks to the trailing #) until 2% outputs 1, which causes _ to switch the direction to left, then | to up, which wraps around to the < on the second row, which outputs and exits. We increment the second-to-the-top element of the stack every time through the loop, then divide the top by 2.

Jolf, 6 bytes
Try it here!
Zlm)j2
Zl   2  count the number occurrences of 2 in
  m)j   the prime factorization of j (input)

Rather simple... Kudos to ETHProductions for ousting Jolf with the version that really should work!

6 bytes seems to be the magic number for this challenge

ES6, 22 bytes
n=>31-Math.clz32(n&-n)

Returns -1 if you pass 0.

Ah, nice. I forgot about clz32 :P

PARI/GP, 17 bytes
n->valuation(n,2)

Retina, 29 17
+`\b(1+)\1$
;$1
;

Try it online!
2 bytes saved thanks to Martin!
Takes unary input. This repeatedly matches the largest amount of 1s it can such that that number of 1s matches exactly the rest of the 1s in the number. Each time it does this it prepends a ; to the string. At the end, we count the number of ;s in the string.
If you want decimal input, add:
\d+
$0$*1

to the beginning of the program.

Brachylog, 27 15 bytes
$pA:2xlL,Al-L=.

Explanation
$pA             § Unify A with the list of prime factors of the input
   :2x          § Remove all occurences of 2 in A
      lL,       § L is the length of A minus all the 2s
         Al-L=. § Unify the output with the length of A minus L

6502 machine language, 7 bytes
To find the place value of the least significant 1 bit of the nonzero value in the accumulator, leaving the result in register X:
A2 FF E8 4A 90 FC 60

To run this on the 6502 simulator on e-tradition.net, prefix it with A9 followed by an 8-bit integer.
This disassembles to the following:
count_trailing_zeroes:
    ldx #$FF
loop:
    inx
    lsr a     ; set carry to 0 iff A divisible by 2, then divide by 2 rounding down
    bcc loop  ; keep looping if A was divisible by 2
    rts       ; return with result in X

This is equivalent to the following C, except that C requires int to be at least 16-bit:
unsigned int count_trailing_zeroes(int signed_a) {
    unsigned int carry;
    unsigned int a = signed_a;  // cast to unsigned makes shift well-defined
    unsigned int x = UINT_MAX;
    do {
        x += 1;
        carry = a & 1;
        a >>= 1;
    } while (carry == 0);
    return x;
}

The same works on a 65816, assuming MX = 01 (16-bit accumulator, 8-bit index), and is equivalent to the above C snippet.

05AB1E, 4 bytes
bR1k

Try it online!
bR1k  # full program
   k  # get 0-based index of first occurrence of...
  1   # literal...
   k  # in...
      # implicit input...
b     # in binary...
 R    # reversed...
   k  # -1 if not found (this will never happen, as the only time a binary number will not contain 1 is if it is 0 which is not considered as valid input)
      # implicit output

Smart approach! :) And also works fine for negative numbers, since the minus sign is at the end after the Reverse. Here a test suite with all test cases.

@KevinCruijssen Cool, thanks for that. I've tried before to golf down the test suite header (just for fun) by replacing " → " with … → , but for some reason interpreting → as a compressed string gives â (with an unprintable, Start of Selected Area, at the end)… do you have any idea why this happens? I'm curious to know :)

I'm just guessing here, but since → is not part of the 05AB1E codepage, and is 3 bytes in UTF-8, the space plus the first two bytes of the 3-byte character → are being printed, and the last byte of → is simply ignored. Still not too sure why it becomes â, though.. If I just use …→ as program it simply outputs that 3-byte character as is, even though … usually gives an error if not three characters are given (i.e. …a results in an error).

@KevinCruijssen I think I know why now. Using this online tool I was able to convert → to UTF-8 codepoints, giving e2 86 92. U+00E2 is â, U+0086 is Start of Selected Area, and U+0092 is Private Use Two.

Desmos, 37 characters
Graph link: https://www.desmos.com/calculator/y5lqwruzjp
Before use, make sure c is set to 0, and that the first line contains whichever number you want to input. When running, you can either press the metronome button to automatically run the program or press the arrow button to run one iteration of the code.
    <input>
    i=ans_0
    c=0
    c->{mod(i,2^(c+1))=0:c+1,c}

How it works

The <input> is the actual number being inputted. For simplicity, it is not counted for characters.
ans_0 reads the 0th line (being the input), and sets i to it.
c-> declares an action, which updates c to the result.
Curly brackets declare a conditional statement. The results are c+1 if the condition is true, and c if not.
mod() is the modulus command. It divides the first statement by the second, and gives the result.
i, as mentioned, is the input.
2^(c+1) is simply 2 raised to c+1. The +1 is used to check the next value of c. An exponent is used to repeatedly divide i by 2.
=0 is the condition, used to check if the remainder is equal to 0 (i is divisible).

So, the graph first takes c, and tries to update it. It raises 2 to c+1 (to check if the c can increment), then divides the input (stored with i) by the result and returns the remainder. It then checks if that remainder is equal to 0, and if so, it sets increments c by 1. Otherwise, it doesn't change c.

Welcome to Code Golf, and nice answer!

Nice, answer, but ans_0 will not paste correctly as is. You need to add a backslash before ans, so it would actually be i=\ans_0. Also, {...} doesn't paste correctly either, you will need to add backslashes in front of both brackets and in front of the mod as well.

Also 2^(c+1) will not paste correctly either. It doesn't really matter though, because it can be golfed down to 2^c2.

One last thing: In CGCC, answers are scored in bytes, not characters, though that doesn't really matter here. What I'm confused about is how are you getting 37 bytes? Could you provide the raw code without all the spaces and <input>?

DUP, 20 bytes
[$2/%0=[2/f;!1+.][0]?]f:

Try it here!
Converted to recursion, output is now the top number on stack. Usage:
94208[2/\0=[f;!1+][0]?]f:f;!

Explanation
[                ]f: {save lambda to f}
 2/\0=               {top of stack /2, check if remainder is 0}
      [     ][ ]?    {conditional}
       f;!1+         {if so, then do f(top of stack)+1}
              0      {otherwise, push 0}

PowerShell, 36 bytes
param($a)for(;!($a%2)){$a/=2;$o++}$o

Takes input $a, then enters a for() loop. There is no setup, but the conditional means the loop ends when $a is no longer even. Inside the loop, we just divide $a by 2 and increment a counter, then output the counter.
The above correctly accounts for negative numbers (in PowerShell, the % operator follows the sign of the dividend, but any non-zero number is truthy, the ! of which is falsey).

C, 44 40 38 36 bytes
2 bytes off thanks @JohnWHSmith. 2 bytes off thanks @luserdroog.
a;f(n){for(;~n&1;n/=2)a++;return a;}

Test live on ideone.

You might be able to take 1 byte off by replacing the costly !(n%2) with a nice little ~n&1.

@JohnWHSmith. That was nice!! Thanks

Remove the =0. Globals are implicitly initialized to 0.

@luserdroog. Thanks, I didn't know about that.

Correct me if I'm wrong but since this function uses the global variable a, isn't it only guaranteed to work the first time it's called? I didn't know that was allowed.

JavaScript ES6, 36 38 bytes
Golfed two bytes thanks to @ETHproductions
Fairly boring answer, but it does the job. May actually be too similar to another answer, if he adds the suggested changes then I will remove mine.
b=>{for(c=0;b%2-1;c++)b/=2;alert(c)}

To run, assign it to a variable (a=>{for...) as it's an anonymous function, then call it with a(100).

Nice answer! b%2==0 can be changed to b%2-1, and c++ can be moved inside the last part of the for statement. I think this would also work: b=>eval("for(c=0;b%2-1;b/=2)++c")

@ETHproductions So it can! Nice catch :)

One more byte: b%2-1 => ~b&1 Also, I think this fails on input of 0, which can be fixed with b&&~b&1

Froze my computer testing this on a negative number. b%2-1 check fails for negative odd numbers.

CJam, 8 bytes
rizmf2e=

Read integer, absolute value, prime factorize, count twos.

Japt, 9 5 bytes
¢w b1

Test it online!
The previous version should have been five bytes, but this one actually works.
How it works
       // Implicit: U = input integer
¢      // Take the binary representation of U.
w      // Reverse.
b1     // Find the first index of a "1" in this string.
       // Implicit output

, 8 chars / 10 bytes
ïⓑᴙą1

Try it here (Firefox only).
Explanation
Converts input to binary, reverses it, then gets index of first 1.

Mathematica, 20 bytes
#~IntegerExponent~2&

Yet another long, un-golfable built-in...

R, 30 bytes
sum(gmp::factorize(scan())==2)

Assumes gmp package installed

Oracle SQL 11.2, 111 bytes
WITH v(i)AS(SELECT 1 FROM DUAL UNION ALL SELECT i+1 FROM v WHERE MOD(:1/POWER(2,i),1)=0)SELECT MAX(i)-1 FROM v;

Un-golfed
WITH v(i) AS
(
  SELECT 1 FROM DUAL
  UNION ALL
  SELECT i+1 FROM v WHERE MOD(:1/POWER(2,i),1)=0
)
SELECT MAX(i)-1 FROM v;

PHP, 36 28 bytes
Used a different approach than most others. I'm checking divisibility by 2^N where I'm increasing N until it's no longer divisible by it.
for(;0==$argv[1]%2**++$b;);echo$b-1;

Run like this (-d added for aesthetics only):
php -d error_reporting=32757 -r 'for(;0==$argv[1]%2**++$b;);echo$b-1; echo"\n";' -- -65536

Implementing orlp's log algorithm would be even shorter. I don't like the requirement to create a file for PHP golfs, but this would be the shortest:
<?=log(($x=$argv[1])&-$x,2);

Edit: I found out you can actually run that without creating a file, by piping it like this:
echo '<?=log(($x=$argv[1])&-$x,2);' | php -- -65536

Javascript ES6, 39 chars
n=>n.toString(2).match(/0*$/)[0].length

Test:
[14,20,94208,7,-4].map(n=>n.toString(2).match(/0*$/)[0].length) == "1,2,12,0,2"

Python, 48 chars
print len(str(bin(int(input()))).split("1")[-1])

Simply counts the number of 0s at the end of the binary number

R, 56 46 40 bytes
x=scan();a=0;while(!x%%2){x=x/2;a=a+1};a

Another answer than @mnel's one without the gmp package.
Thanks to @user5957401 for saving 10 bytes
Thanks to @Frédéric for saving 6 bytes

you could shorten your while condition.
while(!x%%2) should do the trick.

Since OP's asking for either a program or a function, you could golf some bytes by taking x as a scan : x=scan();a=0;...

Excel, 20 bytes
Works up to 2^53 (9,007,199,254,740,990)
=LOG(GCD(A1,2^53),2)

Using Binarys, a 36 byte solution that only works up to 511:
=10-FIND(2,DEC2BIN(A2)+DEC2BIN(-A2))

K (ngn/k), 9 8 5 7 bytes
*&|~~2\

Try it online!

MMIX, 12 bytes (3 instrs)
This is straight out of Knuth volume 4a.
27FF0001 DA00FF00 F8010000

Disassembly and explanation
rho SUBU $255,$0,1      // tmp = x - 1
    SADD $0,$255,$0     // x = popcnt(tmp & ~x)
    POP  1,0            // return x

No, seriously, that's it. An input of 0 gives an output of 64.

Desmos, 22 bytes
f(n)=log_2(gcd(n,2^n))

Try It On Desmos!
Doesn't work for 94208 because it's too large for the program. Below is one that supports much more numbers:
43 bytes
f(n)=log_2(gcd(n,2^{floor(log_2(abs(n)))}))

Try It On Desmos!

Wow this is some insight you got there

@Seggan Thanks! Found the trick a quite a while ago when I was trying to do prime factorization in Desmos.

Prolog (SWI), 39 33 32 bytes
A-B:-A/\1<1,A//2-D,B is D+1;B=0.

Try it online!
-6 bytes thanks to Jo King!
-1 byte thanks to Steffan!

Combining the two clauses saves a byte: A-B:-A/\1<1,A//2-D,B is D+1;B=0.

@Steffan oh, of course it does. I thought of that and then just didn't try it for some reason. Thanks

C, 23 bytes
f(x){x=x&1?0:f(x/2)+1;}

Essentially just counts leading 0s recursively.

Perl 6  28  27 bytes
{($_+&-$_).polymod(2 xx*)-1}
{($_+&-$_).base(2).chars-1}

Usage:
my &code = {($_+&-$_).base(2).chars-1}

say code    14; # 1
say code    20; # 2
say code 94208; # 12
say code     7; # 0
say code    -4; # 2

Javascript, 45 39 38 bytes
1 byte off thanks @manatwork.
i=>/0*$/.exec(i.toString(2))[0].length

f=
i=>/0*$/.exec(i.toString(2))[0].length

F=i=>document.body.innerHTML+='<pre>f('+i+') -> '+f(i)+'\n</pre>'

F(14)
F(20)
F(94208)

.exec() is 1 character shorter, just have to reverse it: /0*$/.exec(i.toString(2)).

@manatwork. Good one, thanks!

Java, 44 39 bytes
int f(int n){return n%2==0?1+f(n/2):0;}

Works for odd, zero, and negative numbers.
Golfed 5 bytes because input will not be zero.

FYI, this is almost exactly like mine: http://codegolf.stackexchange.com/a/71853/14215

works for zero But we don't know what to do for zero.

@Geobits Shoot. I didn't see yours earlier! I was looking for a Java solution, but I must have skipped over it. Sorry.

@Dennis Good point. What I mean is that it will not crash, throw errors, or go into an indefinite loop.

Lol 44 with strikethrough looks almost exactly the same ;)

Seriously, 9 bytes
,wii2=*.

Contains an unprintable (0x7F) at the end. Hexdump:
2c77 6969 323d 2a2e 7f

Try it online!
Explanation:
,wii2=*.<0x7F>
,w              get prime factorization of input (list of base, exp pairs)
  ii            flatten first (base, exp) pair so that base, exp is top of stack
    2=*         multiply exponent by 1 if base is 2 else 0
       .<0x7F>  print top item and exit

jq, 26 characters
[while(.%2==0;./2)]|length

Sample run:
bash-4.3$ jq '[while(.%2==0;./2)]|length' <<< 94208
12

bash-4.3$ jq '[while(.%2==0;./2)]|length' <<< -4
2

On-line test:

94208
-4

POSIX shell and GNU/BSD utilities, 43 30 bytes
factor ${1#-}|rs -T|grep -xc 2

We simply count the number of 2s in the output of the factor command.

Pure Bash, 40
If 0 could not be submited as input... Thanks to @TobySpeight for help me to drop a lot.
for((o=0;1<<o&~i;++o));do :;done;echo $o

Proof
pureBashStr='for((o=0;1<<o&~i;o++));do :;done;echo $o'
echo ${#pureBashStr}
40

for i in 14 20 64#w0000 94208 7 -4 ;do
    printf " %8s: %4d\n" $i $(
        eval $pureBashStr)
  done
       14:    1
       20:    2
 64#w0000:   29
    94208:   12
        7:    0
       -4:    2

+10 to support 0 case: 50
pureBashStr='for((o=0;1<<o&~i;o++));do((i))||break;done;echo $o'
i=0
printf " %8s: %4d\n" $i $(eval $pureBashStr)
        0:    0

i cannot be zero, according to the question.  I think you can simplify the test to o=0;until((1<<o&i));do((++o));done;echo $o for 43 bytes.

Or even for((o=0;1<<o&~i;++o));do :;done;echo $o for 41.

PHP, 40 bytes
function e($i){return $i%2?0:e($i/2)+1;}

Thank you for the syntax highlighting edit, @rink.atendant.6

One more byte can be saved: the space between return and $i.

I think this solution should be re-labelled as PHP 7.3. PHP 7.4 introduced arrow functions that allow a much shorter solution.

Groovy, 83 bytes
There was not a groovy answer yet, so here goes. Definitely room for improvement.
int n=args[0].toInteger();def e(int n){x=0;while(n%2==0){n/=2;x++;};print x;};e(n);

You can use it with:
groovy filename.groovy "94208"

Python 2, 27 bytes
e=lambda n:~n%2and e(n/2)+1

In Python 3, you'd have to use e(n//2), since ~ operator doesn't work with floats.

Try ~n-2and-~e(n-2)

R, 37 35 bytes
f=function(n)"if"(n%%2,0,1+f(n/2))

Checks if the current number is divisible by two. If not, returns 0, if it is, divides and recursively calls itself again while setting up a counter to add 1.
HT -- Giuseppe for replacing ifelse with "if" to lose 2 characters

This could be f=function(n)"if"(n%%2,0,1+f(n/2)) which should be 35 bytes, I think.

You are correct.
I don't think I understand how this works though.
"rnorm"(10) will summon the rnorm function with an input of 10. But the if function doesn't work with multiple inputs, and "rno"(10) won't work to summon rnorm, so its not a straightforward look at the search path to get us from "if" to ifelse. Is there any chance you could explain?

That code is actually applying the if function, not ifelse. if is one of R's reserved words, but it's actually a 3-argument function if(cond,cons.expr,alt.expr), and the "usual" syntax is a sugared version. Heck, for is a 3-argument function for(var,seq,expr). But wrapping a function name in quotes still lets you apply it, probably by calling match.fun under the hood.

Thoroughly appreciate this explainer. Thanks.

SmileBASIC, 45 bytes
INPUT N@L
IF!(N<<31)THEN N=N>>1Q=Q+!GOTO@L
?Q

I'm pretty sure N<<31 is the shortest way to check the lowest bit in SB, since  MOD  and  AND  are so long.

Pure bash, 37 bytes
(($1%2))&&echo 0||echo $[1+`$0 $1/2`]

A recursive solution.

@Makonede I don't see any missing parenthesis. There are two left parentheses at the beginning, two matching right parentheses after the "2", and no other parentheses in the script.  Plus I tried it out again and it works.  (Save it under some name and pass it one integer as a command line argument.) This is from almost 4 years ago, and I barely even recall doing it!

Templates Considered Harmful, 56 bytes
Fun<If<Rem<A<1>,I<2>>,F,Add<T,Ap<A<0>,Div<A<1>,I<2>>>>>>

Try it online!
Anonymous function that takes an int as input. If it is odd, return 0. Otherwise, add 1 and run function again with input/2.
Fun<
    If<Rem<Arg<1>,Int<2>>,
       Int<0>,
       Add<Int<1>,
           Ap<Arg<0>,
              Div<Arg<1>,Int<2>>
           >
       >
    >
>

Nice answer! (and an interesting language!)

Thank you! I love TCH.

BASIC, 36 bytes
while(!mod(a,2)):a=a/2:b=b+1:wend:?b

Try it online!
It's never going to win, but it's interesting to see how competitive good old fashioned BASIC can be in this sort of thing. I managed to tie with a lot of similar 36 byte solutions in trendier languages like C and Javascript, which is good enough for me.
The implementation is totally straightforward, dividing then incrementing a counter for as long as there is no remainder. I'm sure a more creative solution could reduce this byte count.
I noted that the posted solution algorithms don't account for the actual input, so I've done it as READ/DATA in the header and footer. All the test cases are there - just change  the REMark so your desired test has no REM to evaluate. Or put your own "DATA whatever" line and see how my algorithm performs.

MathGolf, 4 bytes
±â1=

Bug-abuse, since it should have been 5 bytes..
Try it online.
Explanation:
±     # Get the absolute value of the (implicit) input-integer
 â    # Convert it to a reversed list of bits
  1=  # Get the 0-based index of the first 1
      # (after which the entire stack is output implicitly as result)

â should convert the integer to a binary-list, but instead converts it to a reversed binary-list, saving us the need for an explicit x to revert it.

Python 3.8 (pre-release), 50 bytes
lambda n: sum(1 for c in bin(n)[::-1] if c=='0')-1

Try it online!

JavaScript (30 bytes)
A couple of years later, and I've come across another solution after experimenting with bitwise operators. Not the shortest JS answer, but certainly pretty, if you ask me.
n=>(-n&n).toString(2).length-1

><>, 13 bytes
0$:2,@2%?n1+!

Try it online!
Explanation
   0           !  # initialize evenness as 0 on 1st iteration and skip on subsequent
    $:2,@         # divide a copy of the input by 2 and move to bottom of stack
         2%       # mod the 2nd copy by 2
           ?n     # print evenness if it's true (non-0)
             1+   # increment evenness for next iteration
    $             # error out after printing

Thunno 2, 4 bytes
Af2c

Attempt This Online!
Explanation
Af2c  # Implicit input
A     # Get the absolute value
 f    # Push the prime factors
  2c  # Count the 2s
      # Implicit output

Rockstar, 100 bytes
listen to N
X's 0
while 1
let M be N/2
turn up M
if M's N/2
build X up
let N be M
else
break

say X

Try it (Code will need to be pasted in)

Julia 0.6, 22 bytes
~x=length(bin(x&-x))-1

Try it online!
Port of orlp's Python answer. The function bin is deprecated in Julia 0.7 and removed in 1.0.

Nekomata, 2 bytes
ˡ½

Attempt This Online!
ˡ       Apply the following function repeatedly until it fails,
            and count the number of steps
 ½      Check if the input is even, and halve it

Pascal, 78 B
The recursive definition beats the iterative definition in length.
However, the abort condition odd(x) is not guaranteed to be fulfilled for the entire domain of f.
If x is 0, it is not odd and x div 2 cannot turn 0 into an odd number.
Hence in production use you will prefer a while odd(x) loop (unless the domain is restricted to exclude zero).
function f(x:integer):integer;begin if odd(x)then f:=0 else f:=1+f(x div 2)end

Pylons, 22 bytes.
:Ai0?Aw[A2A/]1+,2A%1g}

Man, this turned out a lot longer than I thought it would.
Turns out it broke on 0 input, so I fixed it.
How it works:
:Ai     # Set A equal to command line input.
0       # Push 0 to the stack.
?A      # Check if A is equal to the top of the stack, if so, skip the next instrutction. In this case, the while loop.
w       # Start a while loop.
 [A2A/] # Set A equal to A / 2.
 1+     # Push 1 to the stack and add it to the number at the top of the stack.
 ,      # Switch to loop iteration.
 2A%    # Push A%2 to the loop condition stack.
    1g  # Check if 1 is greater than the top of the loop condition stack.
      } # End the while loop
        # Print the stack at the end of the instruction set.

Turing Machine, 53 char
   B    1   i

0  B4L  i1R

1  B2L  11R

2       B3L B7L

3           10R

4  B5L

5  16R

6  B0R  16R

7  Bh   B7L

*       1*L
It accepts as an input a string of ones and outputs a string of ones. It repeatedly divides the number by 2 and adds 1 to the count after every halving. Try it out here.

Whitespace, 109 bytes
Unfortunately I can't put the code here because it gets recognized as formating so this will have to do. http://pastebin.com/cmH30iUF
Try it here: http://ws2js.luilak.net/interpreter.html Just paste the code, type a number, and hit enter.

Another option is to use STL for the code here, since link-only answers are discouraged. Here's an example.

MS SQL, 81 bytes
For funsies. convert( varbinary() ) end up taking more space than the modulo loop.
create proc p @n int as declare @i int=0while @n%2=0 select @i+=1,@n=@n/2print @i
Test with
p 14;
go
p 20;
go
p 94208;
go
p 7;
go
p -4;
go

dc, 21 bytes
#!/usr/bin/dc
?[dd2/r2%0=f]dsfxz2-p

Reads the input, then successively divides by 2, building a stack as we go.  When we get to an odd number, count the stack depth, adjusting for the odd number and its duplicate.

Perl 5, 26 bytes
25, plus 1 for -pe instead of -e.
$i++,$_/=2until$_%2;$_=$i

or
$_=sprintf'%b',$_;s/.*1//

(The latter has output in unary.)

Scala 42 bytes
def e(n:Int):Int=if(n%2==0)e(n/2)+1 else 0

Similar to Java, but 2 bytes smaller.

Microscript II, 28 27 bytes
0s<N[sv2sl%!(.5*v>1+s<l)]>o

There's probably still room for improvement here.

Perl 5 -p, 28 bytes
$_/=2;/\./||++$\&redo}{$\|=0

Try it online!

Julia 1.5.3
Not sure how to count bytes, but Julia has a built-in function for this.
help?> ?trailing_zeros
search: trailing_zeros

  trailing_zeros(x::Integer) -> Integer

  Number of zeros trailing the binary representation of x.

  Examples
  ≡≡≡≡≡≡≡≡≡≡

  julia> trailing_zeros(2)
  1

Modifying the Python solution gives the following:
julia> f=n->length(string(n&-n,base=2))-1
#1 (generic function with 1 method)

julia> f(94208)
12

Welcome to the site! Is it possible you could edit in an actual answer (keep in mind that builtin functions are an answer by themselves), maybe using the template provided by TryItOnline to make your actual answer clearer and to provide a testing environment for other users?

Perl 5 + -pl060, 21 bytes
26 bytes using old rules scoring flags.
Uses the -l060 flag to preset $\ to 0, and increments it until $_/=2 is no longer even.
$_/=2,++$\until$_%2}{
Try it online!

Japt, 7 bytes
v ©ÒßUz

Try it
4 bytes
Originally had this, but it's the same as ETH's solution.
¤Ôb1

Try it
Explanations
v ©ÒßUz     :Implicit input of integer U
v           :Divisible by 2? (returns 0 or 1)
  ©         :Logical AND with
   Ò        :Negate the bitwise NOT of
    ß       :Recursive call with argument
     Uz     :  U floor divided by 2

¤Ôb1     :Implicit input of integer U
¤        :Convert to binary string
 Ô       :Reverse
  b1     :First 0-based index of 1

Ly, 41 bytes
n0sG2*,*[:2%[lu;]pl`sp:2/r01[p`0IL]p-rpr]

Try it online!
Well, this was trickier than I expected...  Division in Ly yields floating point numbers, which was a challenge for this one.  Figuring out how to work around that was fun though.  :)
n                                         - read the number onto the stack
 0s                                       - init accumulator to 0
   G                                      - push 1 if "n>0"
    2*,                                   - map 0->-1 and 1->0
       *                                  - effectively "n=abs(n)"
        [                               ] - infinite loop
         :2%                              - push 1|0 for "is it odd?"
            [   ]p                        - if odd...
             lu;                          - load accumulator, print and exit
                  l`sp                    - increment accumulator
                      :2/                 - calc number we want (as float)
                         r0               - init "int" result to 0 on bottom of stack
                           1[p    ]p      - loop while to of stack is 1
                              `           - increment "int" result
                               0I         - load "float" result
                                 L        - is "int" < "float"?
                                    -     - decrement "n" by "int" result
                                     rpr  - delete bottom of stack

Commodore C64 BASIC, 86 83 BASIC Bytes used
This method in Commodore BASIC uses the def fn function, which is somewhat limited but can be useful. My favourite YouTube Channel 8-BIT Show and Tell talks about this and other rarely used commands in some depth here. If you are interested, it's worth mulling over.
0deffnm(a)=a-int(a/2)*2:inputx:y=-(fnm(x)=0):ify=0goto2
1x=x/2:iffnm(x)=0theny=y+1:goto1
2printy

How it works
The function that I've defined (referenced as fnm(x)) simply acts like a modulus operator in modern days computer programming languages like C and C++. In this instance, we are returning the remainder of any division by 2.
The inputx waits for a numeric input, which can be an integer or a floating point number (in fact, Commodore BASIC only really deals with floating point numbers in the ROM, but that's for another time). So note that I've not included a sanity check for floats, nor for 0, which will be an endless loop.
Once you enter a value, y=-(fnm(x)=0) is a short-hand any byte-saving way of if fn m(x) = 0 then let y = 0: end: else let y = 1. Note that like many BASIC dialects, Commodore BASIC uses a single equals for assignment and comparison. Commodore BASIC also returns -1 as true and 0 as false, as we want to initialise y with the value of 1 if the number entered is an even number, so it will divide equally by two at least once. So, now if y is 0 and the number entered is odd, then we print it and end.
In line 1, we have a loop which divides the number entered into x by 2; if that is even, then we increase the y counter by one and go back to the start of line 1 to divide x by 2 again, and so on until x is odd. On this note the loop ends and y is printed.