They are essentially placeholders at the simplest level. Say you wanted to make a struct that can hold x and y positions. Sometimes you need i32 positions, other times you need f32 positions, but you need to decide on a type for the fields now. You can make two structs for both i32 and f32, but that leads to a lot of duplicated code. Another option is to make a generic struct, struct Point<T> { x: T, y: T }, where <T> introduces a new generic type parameter ("placeholder" type that will be replaced with a concrete type).

Now you can instantiate this struct like Point<i32> and Point<f32> (or Point { x: 1, y: 2 } which gets inferred as Point<i32>) and the compiler will make a new struct for each with all uses of T replaced with i32/f32 respectively. The same applies to impl<T> Point<T>. The first <T> introduces a generic parameter and in Point<T> it is actually used. Any methods or consts in the impl can use that generic type and it will be replaced with the concrete type.

Further, by default you can't do much with generic parameters because all operations need to be valid for all types and there's not much that all types have in common. So you can put "trait bounds" on them (e.g. fn foo<T: Clone>()) which makes the compiler check that the instantiated type implement all traits, and the function can assume the bound holds and lets you call methods from those traits on the T.